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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763267
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763268
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763269
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763270
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763271
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763272
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763273
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763264
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763275
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763276
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763277
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763278
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763279
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763280
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763281
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763282
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763283
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763284
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763285
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763286
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763287
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763288
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763279
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763290
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763291
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763292
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763293
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763294
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763295
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763296
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763297
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763298
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763299
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763300
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763301
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763302
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763303
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763294
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763305
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763306
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763307
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763308
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763309
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763310
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763311
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763312
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763313
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763314
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763315
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763316
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(5)-sdccf-ChinaUnix博客
  • 博客访问: 91763317
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:19

学习基本概念

developerWorks



识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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


识别游标的类型

游标有三个主要特征:

  • 游标的类型(type):只读、可更新或模糊(ambiguous)
  • 游标的方向(direction):前向或可滚动
  • 游标的作用域(scope)

这些特征将在接下来的几个小节中详细讨论。

DB2 对三种游标类型的处理有所不同,这些不同主要体现在性能方面。我们来看看每种类型。

如果 DB2 知道游标是只读的,就可以应用某些性能方面的优势:

  • DB2 通常可以通过执行记录组块,一次从服务器检索多行,而不需要获取允许更新行的锁。
  • DB2 有时候可以为查询选择更好的访问计划。

如果知道游标不会用于更新或删除行,就应该将它指定为只读,具体做法是将 FOR READ ONLY (或 FOR FETCH ONLY)添加到游标的 SELECT 语句中。如果游标的 SELECT 语句要联结多个表,或者包括诸如 ORDER BYGROUP BY 之类的子句,那么游标会被(自动地)归类为只读。

如果在游标的 SELECT 语句中指定了 FOR UPDATE 子句,那么该游标就是可更新的,意即可以通过 Update Where Current Of 语句更新行。SELECT 语句中只能引用一个表(或视图)。由于必须维护数据完整性,DB2 只能为可更新游标执行最低限度的优化。

SQL Reference 中借助术语可删除游标(deletable cursor)来定义可更新游标。这两个术语的在意思上几乎是一样的。请参阅 SQL Reference 中关于 DECLARE CURSOR 的描述。

顾名思义,当 DB2 不能根据游标定义确定它是只读游标还是可更新游标时,该游标就是模糊 游标。换句话说,当游标的 SELECT 语句既没有指定 FOR READ ONLY,也没有指定 FOR UPDATE 时,它就是模糊游标。对于模糊游标,DB2 根据针对应用程序的 BIND 命令的 BLOCKING 选项的值来选择是否为 select 使用记录组块。如果执行了记录组块,但是又发生了更新,就会产生负面的性能影响,所以最好尽量避免使用模糊游标。





回页首


DB2 嵌入式 SQL 应用程序的游标支持只允许一次处理一行,并且而且只能按顺向。换句话说,每条 FETCH 语句会把结果集中接下来的一行返回给应用程序,这是应用程序通过游标获得行的惟一方式。

CLI 和 Java 平台支持可滚动游标。这些游标游标可以定位到结果集中一个绝对行号上(可以在当前位置之前,也可用在当前位置之后),或者移动一个相对行数(向前或向后)。要了解关于可滚动游标的更多信息,请参阅本系列第 4 和第 5 篇教程(分别关于 ODBC/CLI 和 Java 平台,见 参考资料)。





回页首


谈到游标的作用域,我们指的是能够使用游标来获取行的一段期间。这段期间从游标的 OPEN 语句成功完成开始。默认情况下,当游标关闭,或者执行提交时,游标的作用域随之结束。在下一节中可以看到,通过提交来结束游标的作用域有一定的害处,但是有一种方法可以避免。





回页首


通常,应用程序应该非常频繁地执行 COMMIT 语句。这些提交可以让锁得以释放,从而最小化应用程序之间的并发问题。然而,当涉及游标时,提交可能导致问题。这就是引入 WITH HOLD 子句的原因。

作为一个例子,考虑这样一个应用程序,其中有一条 SQL 语句使用游标读取 10,000 行记录。该应用程序检查每行的内容,并通过设置一个状态列的值来更新该行。要等到所有 10,000 行都处理完才进行提交可能会导致锁冲突,因此变为每处理 20 行就提交一次。然而,在缺省情况下,提交操作会关闭游标,因此结果集中的位置将会丢失,应用程序又不得不进行一些特殊的处理,才能继续从上一次的地方开始。

解决这个问题的办法是更改游标的定义,加入 WITH HOLD 子句。这样,提交操作就会让游标处于打开状态,从而避免释放维护游标位置时所需的锁。换句话说,WITH HOLD 子句可以将游标的作用域延长至提交之后。下面是 WITH HOLD 游标的一个例子:

DECLARE C1 CURSOR WITH HOLD FOR SELECT * FROM STAFF

WITH HOLD 子句对于回滚期间游标发生什么事情没有影响。一旦游标关闭,则所有相关的锁也将被释放。

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