Chinaunix首页 | 论坛 | 博客
  • 博客访问: 104559164
  • 博文数量: 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博客
  • 博客访问: 104559165
  • 博文数量: 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博客
  • 博客访问: 104559166
  • 博文数量: 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博客
  • 博客访问: 104559167
  • 博文数量: 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博客
  • 博客访问: 104559168
  • 博文数量: 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博客
  • 博客访问: 104559169
  • 博文数量: 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博客
  • 博客访问: 104559170
  • 博文数量: 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博客
  • 博客访问: 104559171
  • 博文数量: 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博客
  • 博客访问: 104559172
  • 博文数量: 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博客
  • 博客访问: 104559173
  • 博文数量: 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博客
  • 博客访问: 104559164
  • 博文数量: 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博客
  • 博客访问: 104559175
  • 博文数量: 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博客
  • 博客访问: 104559176
  • 博文数量: 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博客
  • 博客访问: 104559177
  • 博文数量: 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博客
  • 博客访问: 104559178
  • 博文数量: 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博客
  • 博客访问: 104559179
  • 博文数量: 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博客
  • 博客访问: 104559180
  • 博文数量: 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博客
  • 博客访问: 104559181
  • 博文数量: 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博客
  • 博客访问: 104559182
  • 博文数量: 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博客
  • 博客访问: 104559183
  • 博文数量: 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博客
  • 博客访问: 104559184
  • 博文数量: 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博客
  • 博客访问: 104559185
  • 博文数量: 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博客
  • 博客访问: 104559186
  • 博文数量: 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博客
  • 博客访问: 104559187
  • 博文数量: 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博客
  • 博客访问: 104559188
  • 博文数量: 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博客
  • 博客访问: 104559179
  • 博文数量: 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博客
  • 博客访问: 104559190
  • 博文数量: 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博客
  • 博客访问: 104559191
  • 博文数量: 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博客
  • 博客访问: 104559192
  • 博文数量: 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博客
  • 博客访问: 104559193
  • 博文数量: 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博客
  • 博客访问: 104559194
  • 博文数量: 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博客
  • 博客访问: 104559195
  • 博文数量: 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博客
  • 博客访问: 104559196
  • 博文数量: 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博客
  • 博客访问: 104559197
  • 博文数量: 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博客
  • 博客访问: 104559198
  • 博文数量: 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博客
  • 博客访问: 104559199
  • 博文数量: 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博客
  • 博客访问: 104559200
  • 博文数量: 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博客
  • 博客访问: 104559201
  • 博文数量: 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博客
  • 博客访问: 104559202
  • 博文数量: 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博客
  • 博客访问: 104559203
  • 博文数量: 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博客
  • 博客访问: 104559194
  • 博文数量: 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博客
  • 博客访问: 104559205
  • 博文数量: 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博客
  • 博客访问: 104559207
  • 博文数量: 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博客
  • 博客访问: 104559208
  • 博文数量: 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博客
  • 博客访问: 104559209
  • 博文数量: 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博客
  • 博客访问: 104559210
  • 博文数量: 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博客
  • 博客访问: 104559211
  • 博文数量: 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博客
  • 博客访问: 104559212
  • 博文数量: 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博客
  • 博客访问: 104559213
  • 博文数量: 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博客
  • 博客访问: 104559214
  • 博文数量: 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博客
  • 博客访问: 104559215
  • 博文数量: 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博客
  • 博客访问: 104559216
  • 博文数量: 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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135705) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135704) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135703) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135702) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135701) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135700) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135699) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135698) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135697) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135696) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135695) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135694) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135693) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135692) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135691) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135690) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135689) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135688) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135687) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135686) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135685) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135684) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135683) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135682) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135681) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135680) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135679) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135678) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135677) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135676) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135675) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135674) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135673) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135672) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135671) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135670) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135669) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135668) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135667) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135666) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135665) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135664) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135663) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135662) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135661) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135660) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135659) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135658) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135657) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135656) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

阅读(135655) | 评论(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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

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