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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:18:59

学习基本概念

developerWorks



操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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


操纵游标

在本节中,您将更进一步看到如何在嵌入式 SQL 应用程序中使用游标。同样,基本的步骤仍然是声明、打开、获取、更新/删除(可选)和关闭。

为了帮助理解游标的概念,假设 DB2 构建一个结果表来存放通过 SELECT 语句检索到的所有行。游标通过标识或指向表中的当前行,使应用程序可以访问结果表中的行。当使用游标时,应用程序可以连续地从结果表中检索每一行,直到遇到 end-of-data 条件(也就是 NOT FOUND 条件、SQLCODE +100SQLSTATE 02000)。取决于满足搜索条件的行的数量,执行 SELECT 语句得到的结果集可能包含 0 行、1 行或更多的行。

DECLARE CURSOR 语句的语法非常简单。下面是静态 SQL 的一个例子:

DECLARE C1 CURSOR FOR SELECT * FROM STAFF

这条语句的使用可能有点令人费解,因为这条语句不是可执行的。换句话说,这条语句是在嵌入式应用程序的准备阶段处理的,在程序执行期间,当碰到 DECLARE 语句时,不会发生任何事情。全部工作都是在游标打开后完成的。惟一的要求就是,在源文件中,DECLARE CURSOR 语句要出现在 OPEN 语句之前。而在同样的 C 函数中,甚至不需要放入这样的语句。在游标声明时所在的源文件中,每个游标的名称必须是惟一的。

如果使用动态 SQL,那么 DECLARE CURSOR 语句会有有所不同。这里不再使用 SELECT 语句的语法,而是使用一个语句名。这个语句名必须与准备相关的 SELECT 语句时指定的名称相匹配。例如:

EXEC SQL PREPARE STMT1 FROM :STRINGSTMT;
EXEC SQL DECLARE C3 CURSOR FOR STMT1;





回页首


通过打开一个游标,可以准备查询结果集中的行,以供程序使用。open 操作还使游标的位置处于第一个结果行之前,不过只有执行 fetch 命令时,才能访问那一行。

通常,open 操作将占去查询执行过程中的大部分时间,尤其是在有 ORDER BYGROUP BY 子句的情况下就更是如此。

OPEN 语句的语法非常简单。要打开一个名为 c0 的游标,可使用以下语句:

OPEN C0





回页首


对游标执行 fetch 将导致结果集中的下一行变成对程序可用,通常是将结果集各列中的值放入到宿主变量中。结果集中的第 n 列的值被放入 fetch 语句中的第 n 个宿主变量中。

例如,如果为 Select name, dept, id from staff 声明一个游标 c0,那么语句 Fetch c0 into :hv1, :hv2, :hv3 将把 name 列的值放入 hv1,把 dept 列的值放入 hv2,把 id 列的值放入 hv3

如果结果集列可以为空,那么应该再使用一个宿主标识符(null 指示符),DB2 将把一个负值存储在那个变量中,以表示返回的是一个 null 值。例如,将之前的例子改为 Fetch c0 into :hv1, :hv2 :hv2ind, :hv3,这样程序就可以知道员工的部门是否为 null。

通常,会将 fetch 语句放在一个程序循环中,该循环直到 SQLCODE 为 +100 时才结束。此时,结果集中所有的行都已被获取。





回页首


如前所述,可以对游标所指向的行进行 positioned 更新或删除。在更新或删除之前,必须执行一条 fetch 语句,并且返回的 SQLCODE 不能为 +100(或一个错误)。结果集中的每一行都可以以这种方式进行处理。下面是一个例子:

EXEC SQL DECLARE CURSOR C0 FOR SELECT NAME, SALARY FROM STAFF FOR UPDATE OF DEPT;	
EXEC SQL FETCH C0 INTO :HVNAME, :HVSAL;
/* THERE MIGHT BE PROGRAM LOGIC HERE TO CHECK THE EMPLOYEE NAME AND SALARY */
/* AND ONLY EXECUTE THE UPDATE IF SOME CRITERIA APPLY                      */
EXEC SQL UPDATE STAFF SET DEPT = :NEWDEPT WHERE CURRENT OF C0;	

该代码从 STAFF 表中检索雇员信息,并允许更新雇员的部门。DECLARE CURSOR 语句提供查询,其中列出 namesalary 列作为被检索的列,并指出某些行中的 dept 列可以更新。FETCH 语句将雇员和薪水值放入程序变量中。UPDATE 语句用于将之前获取的行中 dept 列的值更新为程序变量 newdept 中的值。

虽然这里没有显示,但通常要使用程序逻辑控制循环,使循环在到达结果集的最后时结束,并且只更新某些行。





回页首


关闭游标可以释放游标的内部存储,并使游标不再可用。关闭游标的语法非常简单:

CLOSE C0

默认情况下,关闭一个游标并不会释放它所持有的锁。要释放锁,还需添加 WITH RELEASE 子句:

CLOSE C0 WITH RELEASE

这使得 DB2 尝试释放所有的读锁。但是,DB2 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

当游标处于打开状态时,可以在任何时候关闭它。也就是说,在关闭游标前,不需要获取整个结果集。游标关闭后,还可以再次打开,就像之前没有被使用过一样。

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