Chinaunix首页 | 论坛 | 博客
  • 博客访问: 110149491
  • 博文数量: 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博客
  • 博客访问: 110149493
  • 博文数量: 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博客
  • 博客访问: 110149496
  • 博文数量: 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博客
  • 博客访问: 110149498
  • 博文数量: 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博客
  • 博客访问: 110149500
  • 博文数量: 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博客
  • 博客访问: 110149503
  • 博文数量: 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博客
  • 博客访问: 110149505
  • 博文数量: 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博客
  • 博客访问: 110149507
  • 博文数量: 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博客
  • 博客访问: 110149499
  • 博文数量: 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博客
  • 博客访问: 110149511
  • 博文数量: 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博客
  • 博客访问: 110149513
  • 博文数量: 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博客
  • 博客访问: 110149515
  • 博文数量: 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博客
  • 博客访问: 110149517
  • 博文数量: 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博客
  • 博客访问: 110149520
  • 博文数量: 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博客
  • 博客访问: 110149521
  • 博文数量: 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博客
  • 博客访问: 110149523
  • 博文数量: 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博客
  • 博客访问: 110149514
  • 博文数量: 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博客
  • 博客访问: 110149526
  • 博文数量: 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博客
  • 博客访问: 110149527
  • 博文数量: 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博客
  • 博客访问: 110149528
  • 博文数量: 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博客
  • 博客访问: 110149529
  • 博文数量: 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博客
  • 博客访问: 110149530
  • 博文数量: 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博客
  • 博客访问: 110149531
  • 博文数量: 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博客
  • 博客访问: 110149532
  • 博文数量: 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博客
  • 博客访问: 110149534
  • 博文数量: 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博客
  • 博客访问: 110149535
  • 博文数量: 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博客
  • 博客访问: 110149536
  • 博文数量: 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博客
  • 博客访问: 110149537
  • 博文数量: 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博客
  • 博客访问: 110149538
  • 博文数量: 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博客
  • 博客访问: 110149529
  • 博文数量: 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博客
  • 博客访问: 110149541
  • 博文数量: 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博客
  • 博客访问: 110149542
  • 博文数量: 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博客
  • 博客访问: 110149543
  • 博文数量: 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博客
  • 博客访问: 110149544
  • 博文数量: 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博客
  • 博客访问: 110149545
  • 博文数量: 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博客
  • 博客访问: 110149546
  • 博文数量: 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博客
  • 博客访问: 110149548
  • 博文数量: 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博客
  • 博客访问: 110149549
  • 博文数量: 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博客
  • 博客访问: 110149550
  • 博文数量: 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博客
  • 博客访问: 110149551
  • 博文数量: 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博客
  • 博客访问: 110149552
  • 博文数量: 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博客
  • 博客访问: 110149553
  • 博文数量: 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博客
  • 博客访问: 110149544
  • 博文数量: 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博客
  • 博客访问: 110149555
  • 博文数量: 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博客
  • 博客访问: 110149556
  • 博文数量: 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博客
  • 博客访问: 110149558
  • 博文数量: 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博客
  • 博客访问: 110149559
  • 博文数量: 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博客
  • 博客访问: 110149560
  • 博文数量: 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博客
  • 博客访问: 110149561
  • 博文数量: 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博客
  • 博客访问: 110149562
  • 博文数量: 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博客
  • 博客访问: 110149563
  • 博文数量: 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博客
  • 博客访问: 110149565
  • 博文数量: 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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111281) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111280) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111279) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111278) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111277) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111276) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111275) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111274) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111273) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111272) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111271) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111270) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111269) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111268) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111267) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111266) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111265) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111264) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111263) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111262) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111261) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111260) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111259) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111258) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111257) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111256) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111255) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111254) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111253) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111252) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111251) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111250) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111249) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111248) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111247) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111246) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111245) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111244) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111243) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111242) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111241) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111240) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111239) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111238) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111237) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111236) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111235) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111234) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111233) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111232) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

阅读(111231) | 评论(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 CURSOR、OPEN、FETCH 和 CLOSE 语句提供的。

通过以下语法,可以执行 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),此时游标关闭。

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