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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks



在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

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