Chinaunix首页 | 论坛 | 博客
  • 博客访问: 91756634
  • 博文数量: 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博客
  • 博客访问: 91756635
  • 博文数量: 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博客
  • 博客访问: 91756636
  • 博文数量: 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博客
  • 博客访问: 91756637
  • 博文数量: 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博客
  • 博客访问: 91756638
  • 博文数量: 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博客
  • 博客访问: 91756639
  • 博文数量: 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博客
  • 博客访问: 91756640
  • 博文数量: 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博客
  • 博客访问: 91756641
  • 博文数量: 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博客
  • 博客访问: 91756642
  • 博文数量: 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博客
  • 博客访问: 91756643
  • 博文数量: 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博客
  • 博客访问: 91756634
  • 博文数量: 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博客
  • 博客访问: 91756645
  • 博文数量: 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博客
  • 博客访问: 91756646
  • 博文数量: 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博客
  • 博客访问: 91756647
  • 博文数量: 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博客
  • 博客访问: 91756648
  • 博文数量: 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博客
  • 博客访问: 91756649
  • 博文数量: 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博客
  • 博客访问: 91756650
  • 博文数量: 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博客
  • 博客访问: 91756651
  • 博文数量: 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博客
  • 博客访问: 91756652
  • 博文数量: 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博客
  • 博客访问: 91756653
  • 博文数量: 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博客
  • 博客访问: 91756654
  • 博文数量: 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博客
  • 博客访问: 91756655
  • 博文数量: 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博客
  • 博客访问: 91756656
  • 博文数量: 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博客
  • 博客访问: 91756657
  • 博文数量: 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博客
  • 博客访问: 91756658
  • 博文数量: 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博客
  • 博客访问: 91756649
  • 博文数量: 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博客
  • 博客访问: 91756660
  • 博文数量: 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博客
  • 博客访问: 91756661
  • 博文数量: 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博客
  • 博客访问: 91756662
  • 博文数量: 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博客
  • 博客访问: 91756663
  • 博文数量: 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博客
  • 博客访问: 91756664
  • 博文数量: 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博客
  • 博客访问: 91756665
  • 博文数量: 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博客
  • 博客访问: 91756666
  • 博文数量: 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博客
  • 博客访问: 91756667
  • 博文数量: 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博客
  • 博客访问: 91756668
  • 博文数量: 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博客
  • 博客访问: 91756669
  • 博文数量: 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博客
  • 博客访问: 91756670
  • 博文数量: 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博客
  • 博客访问: 91756671
  • 博文数量: 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博客
  • 博客访问: 91756672
  • 博文数量: 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博客
  • 博客访问: 91756673
  • 博文数量: 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博客
  • 博客访问: 91756664
  • 博文数量: 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博客
  • 博客访问: 91756675
  • 博文数量: 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博客
  • 博客访问: 91756676
  • 博文数量: 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博客
  • 博客访问: 91756677
  • 博文数量: 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博客
  • 博客访问: 91756678
  • 博文数量: 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博客
  • 博客访问: 91756679
  • 博文数量: 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博客
  • 博客访问: 91756680
  • 博文数量: 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博客
  • 博客访问: 91756681
  • 博文数量: 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博客
  • 博客访问: 91756682
  • 博文数量: 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博客
  • 博客访问: 91756683
  • 博文数量: 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博客
  • 博客访问: 91756684
  • 博文数量: 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博客
  • 博客访问: 91756685
  • 博文数量: 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 将保留用于更新行的锁,并且可能需要为其他操作或交互保留一些读锁。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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