Chinaunix首页 | 论坛 | 博客
  • 博客访问: 104570376
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570377
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570378
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570369
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570380
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570381
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570382
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570383
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570384
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570385
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570386
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570388
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570389
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570390
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570391
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570392
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570393
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570384
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570395
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570396
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570397
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570398
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570399
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570400
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570401
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570402
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570403
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570404
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570405
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570406
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570407
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570408
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570399
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570410
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570411
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570412
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570413
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570414
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570415
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570416
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570417
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570418
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570419
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570420
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570421
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570422
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570423
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570414
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570425
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570426
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570427
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks

DB2 9 基础(730 考试)认证指南,第 6 部分: 数据并发性(3)-sdccf-ChinaUnix博客
  • 博客访问: 104570428
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:17:25

developerWorks



并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141808) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141807) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141806) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141805) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141804) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141803) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141802) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141801) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141800) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141799) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141798) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141797) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141796) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141795) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141794) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141793) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141792) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141791) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141790) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141789) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141788) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141787) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141786) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141785) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141784) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141783) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141782) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141781) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141780) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141779) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141778) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141777) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141776) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141775) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141774) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141773) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141772) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141771) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141770) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141769) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141768) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141767) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141766) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141765) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141764) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141763) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141762) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141761) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141760) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141759) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141758) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


并发性和隔离级别

在单用户环境中,每个事务都是顺序执行的,而不会遇到与其他事务的冲突。但是,在多用户环境下,多个事务可以(而且常常)同时执行。因此每个事务都有可能与其他正在运行的事务发生冲突。有可能与其他事务发生冲突的事务称为交错的并行的 事务,而相互隔离的事务称为串行化 事务,这意味着同时运行它们的结果与一个接一个连续地运行它们的结果没有区别。在多用户环境下,在使用并行事务时,会发生四种现象:

  • 丢失更新:这种情况发生在两个事务读取并尝试更新同一数据时,其中一个更新会丢失。例如:事务 1 和事务 2 读取同一行数据,并都根据所读取的数据计算出该行的新值。如果事务 1 用它的新值更新该行以后,事务 2 又更新了同一行,则事务 1 所执行的更新操作就丢失了。由于设计 DB2 的方法,DB2 不允许发生此类现象。
  • 脏读:当事务读取尚未提交的数据时,就会发生这种情况。例如:事务 1 更改了一行数据,而事务 2 在事务 1 提交更改之前读取了已更改的行。如果事务 1 回滚该更改,则事务 2 就会读取被认为是不曾存在的数据。
  • 不可重复的读:当一个事务两次读取同一行数据,但每次获得不同的数据值时,就会发生这种情况。例如:事务 1 读取了一行数据,而事务 2 在更改或删除该行后提交了更改。当事务 1 尝试再次读取该行时,它会检索到不同的数据值(如果该行已经被更新的话),或发现该行不复存在了(如果该行被删除的话)。
  • 幻像:当最初没有看到某个与搜索条件匹配的数据行,而在稍后的读操作中又看到该行时,就会发生这种情况。例如:事务 1 读取满足某个搜索条件的一组数据行,而事务 2 插入了与事务 1 的搜索条件匹配的新行。如果事务 1 再次执行产生原先行集的查询,就会检索到不同的行集。

维护数据库的一致性和数据完整性,同时又允许多个应用程序同时访问同一数据,这样的特性称为并发性。DB2 数据库用来尝试强制实施并发性的方法之一是通过使用隔离级别,它决定在第一个事务访问数据时,如何对其他事务锁定或隔离该事务所使用的数据。DB2 使用下列隔离级别来强制实施并发性:

  • 可重复的读(Repeatable Read)
  • 读稳定性(Read Stability)
  • 游标稳定性(Cursor Stability)
  • 未提交的读(Uncommitted Read)

可重复的读隔离级别可以防止所有现象,但是会大大降低并发性的程度(可以同时访问同一资源的事务数量)。未提交的读隔离级别提供了最大的并发性,但是后三种现象都可能出现。







可重复读隔离级别是最严格的隔离级别。在使用它时,一个事务的影响完全与其他并发事务隔离:脏读、不可重复的读、幻像都不会发生。当使用可重复的读隔离级别时,在事务执行期间锁定该事务以任何方式 引用的所有行。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么产生的结果数据集总是相同的。因此,使用可重复的读隔离级别的事务可以多次检索同一行集,并可以对它们执行任意操作,直到由提交或回滚操作终止事务。但是,在事务存在期间,不允许其他事务执行会影响这个事务正在访问的任何行的插入、更新或删除操作。为了确保这种行为,锁定该事务所引用的每一行 —— 而不是仅锁定被实际检索或修改的那些行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则所扫描的 1000 行(而不仅是被检索的 10 行)都会被锁定。

那么在现实环境中可重复读隔离级别是如何工作的呢?假定您使用 DB2 数据库跟踪旅馆记录,包括房间预订和房价信息,还有一个基于 Web 的应用程序,它允许顾客按 “先到先服务” 的原则预订房间。如果旅馆预订应用程序是在可重复读隔离级别下运行的,当顾客扫描某个日期段内的可用房间列表时,您(旅馆经理)将无法更改那些房间在指定日期范围内的房价。同样,其他顾客也无法进行或取消将会更改该列表的预订(直到第一个顾客的事务终止为止)。但是,对于生成第一个顾客的列表时没有读取的任何房间记录,您可以修改房价。同样,其他顾客也可以进行或取消这些房间的预订。图 2 说明了这种行为。



RR 隔离级别






读稳定性隔离级别没有可重复读隔离级别那么严格;因此,它没有将事务与其他并发事务的效果完全隔离。读稳定性隔离级别可以防止脏读和不可重复的读,但是可能出现幻像。在使用这个隔离级别时,只锁定事务实际检索和修改的行。因此,如果一个事务扫描了 1000 行,但只检索 10 行,则只有被检索的 10 行(而不是所扫描的 1000 行)被锁定。因此,如果在同一个事务中发出同一个 SELECT 语句两次或更多次,那么每次产生的结果数据集可能不同。

与可重复读隔离级别一样,在读稳定性隔离级别下运行的事务可以检索一个行集,并可以对它们执行任意操作,直到事务终止。在这个事务存在期间,其他事务不能执行那些会影响这个事务检索到的行集的更新或删除操作;但是其他事务可以执行插入操作。如果插入的行与第一个事务的查询的选择条件匹配,那么这些行可能作为幻像出现在后续产生的结果数据集中。其他事务对其他行所做的更改,在提交之前是不可见的。

那么,读稳定性隔离级别会如何影响旅馆预订应用程序的工作方式呢?当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改这个顾客的列表之外的任何房间的房价。同样,其他顾客可以进行或取消房间预订,如果第一个顾客再次运行同样的查询,其他顾客的操作可能会影响他获得的可用房间列表。如果第一个顾客再次查询同一个日期段内的所有可用房间列表,产生的列表中有可能包含新的房价或第一次产生列表时不可用的房间。图 3 说明了这种行为。



RS 隔离级别






游标稳定性隔离级别在隔离事务效果方面非常宽松。它可以防止脏读;但有可能出现不可重复的读和幻像。这是因为在大多数情况下,游标稳定性隔离级别只锁定事务声明并打开的游标当前引用的行。

当使用游标稳定性隔离级别的事务通过游标从表中检索行时,其他事务不能更新或删除游标所引用的行。但是,如果被锁定的行本身不是用索引访问的,那么其他事务可以将新的行添加到表中,以及对被锁定行前后的行进行更新和/或删除操作。所获取的锁一直有效,直到游标重定位或事务终止为止。(如果游标重定位,原来行上的锁就被释放,并获得游标现在引用的行上的锁。)此外,如果事务修改了它检索到的任何行,那么在事务终止之前,其他事务不能更新或删除该行,即使在游标不再位于被修改的行。与可重复读和读稳定性隔离级别一样,其他事务在其他行上进行的更改,在这些更改提交之前对于使用游标稳定性隔离级别的事务(这是默认的隔离级别)是不可见的。

如果旅馆预订应用程序在游标稳定性隔离级别下运行,那么有什么影响呢?当一个顾客检索某个日期段内所有可用房间的列表,然后查看关于产生的列表上每个房间的信息时(每次查看一个房间),您可以更改旅馆中任何房间的房价,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。同样,其他顾客可以对任何房间进行或取消预订,但是这个顾客当前正在查看的房间除外 (对于指定的日期段)。但是,对于第一个顾客当前正在查看的房间记录,您和其他顾客都不能进行任何操作。当第一个顾客查看列表中另一个房间的信息时,您和其他顾客就可以修改他刚才查看的房间记录(如果这个顾客没有预订这个房间的话);但不能修改第一个顾客当前正在查看的房间记录。图 4 说明了这种行为。



CS 隔离级别






未提交的读隔离级别是最不严格的隔离级别。实际上,在使用这个隔离级别时,仅当另一个事务试图删除或更改被检索的行所在的表时,才会锁定一个事务检索的行。因为在使用这种隔离级别时,行通常保持未锁定状态,所以脏读、不可重复的读和幻像都可能会发生。因此,未提交的读隔离级别通常用于那些访问只读表和视图的事务,以及某些执行 SELECT 语句的事务(只要其他事务的未提交数据对这些语句没有负面效果)。

顾名思义,其他事务对行所做的更改在已经提交之前对于使用未提交的读隔离级别的事务是可见的。但是,此类事务不能看见或访问其他事务所创建的表、视图或索引,直到那些事务被提交为止。类似地,如果其他事务删除了现有的表、视图或索引,那么仅当进行删除操作的事务终止时,使用未提交的读隔离级别的事务才能知道这些对象不再存在了。(一定要注意一点:当运行在未提交的读隔离级别下的事务使用可更新游标时,该事务的行为和在游标稳定性隔离级别下运行一样,并应用游标稳定性隔离级别的约束。)

那么未提交的读隔离级别对旅馆预订应用程序有什么影响呢?现在,当一个顾客检索某个日期段内的所有可用房间列表时,您可以更改旅馆中任何房间任何日期的房价,而其他顾客也可以对任何房间进行或取消预订,包括第一个顾客当前正在查看的房间记录(对于指定的日期段)。另外,第一个顾客生成的房间列表可能包含其他顾客正在预订(因此实际上不可用)的房间。图 5 说明了这种行为。



UR 隔离级别






使用的隔离级别不仅影响数据库对并发性的支持如何,而且影响并发应用程序的性能。通常,使用的隔离级别越严格,并发性就越小,某些应用程序的性能可能会越低,因为它们要等待资源上的锁被释放。那么,如何决定要使用哪种隔离级别呢?最好的方法是确定哪些现象是不可接受的,然后选择能够防止这些现象发生的隔离级别:

  • 如果正在执行大型查询,而且不希望并发事务所做的修改导致查询的多次运行返回不同的结果,则使用可重复的读隔离级别。
  • 如果希望在应用程序之间获得一定的并发性,还希望限定的行在事务执行期间保持稳定,则使用读稳定性隔离级别。
  • 如果希望获得最大的并发性,同时不希望查询看到未提交的数据,则使用游标稳定性隔离级别。
  • 如果正在只读的表/视图/数据库上执行查询,或者并不介意查询是否返回未提交的数据,则使用未提交的读隔离级别。






尽管隔离级别控制事务级上的行为,但实际上是在应用程序级指定它们的:

  • 对于嵌入式 SQL 应用程序,在预编译时或在将应用程序绑定到数据库(如果使用延迟绑定)时指定隔离级别。在这种情况下,使用 PRECOMPILE 或 BIND 命令 的 ISOLATION 选项来设置隔离级别。
  • 对于开放数据库连接(Open Database Connectivity,ODBC)和调用级接口(Call Level Interface,CLI)应用程序,隔离级别是在应用程序运行时通过调用指定了 SQL_ATTR_TXN_ISOLATION 连接属性的 SQLSetConnectAttr() 函数进行设置的。(另外,也可以通过指定 db2cli.ini 配置文件中的 TXNISOLATION 关键字的值来设置 ODBC/CLI 应用程序的隔离级别;但是,这种方法不够灵活,不能像第一种方法那样为一个应用程序中的不同事务修改隔离级别。)
  • 对于 Java 数据库连接(Java Database Connectivity,JDBC)和 SQLJ 应用程序,隔离级别是在应用程序运行时通过调用 DB2 的 java.sql 连接接口中的 setTransactionIsolation() 方法设置的。

当没有使用这些方法显式指定应用程序的隔离级别时,默认使用游标稳定性隔离级别。这个默认设置应用于从命令行处理程序(CLP)执行的 DB2 命令、SQL 语句和脚本以及嵌入式 SQL、ODBC/CLI、JDBC 和 SQLJ 应用程序。因此,也可以为从 CLP 执行的操作(以及传递给 DB2 CLP 进行处理的脚本)指定隔离级别。在这种情况下,隔离级别是通过在建立数据库连接之前在 CLP 中执行 CHANGE ISOLATION 命令设置的。

在 DB2 UDB 8.1 及更高版本中,能够指定特定查询所用的隔离级别,方法是在 SELECT SQL 语句中加上 WITH [RR | RS | CS | UR] 子句。使用这个子句的简单 SELECT 语句示例如下所示:

 
SELECT * FROM EMPLOYEE WHERE EMPID = '001' WITH RR

如果应用程序在大多数时候需要比较宽松的隔离级别(以支持最大的并发性),但是对于其中的某些查询必须防止某些现象出现,那么这个子句就是帮助您实现目标的好方法。

阅读(141757) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~