Chinaunix首页 | 论坛 | 博客
  • 博客访问: 106932407
  • 博文数量: 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博客
  • 博客访问: 106932408
  • 博文数量: 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博客
  • 博客访问: 106932409
  • 博文数量: 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博客
  • 博客访问: 106932410
  • 博文数量: 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博客
  • 博客访问: 106932411
  • 博文数量: 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博客
  • 博客访问: 106932412
  • 博文数量: 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博客
  • 博客访问: 106932413
  • 博文数量: 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博客
  • 博客访问: 106932404
  • 博文数量: 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博客
  • 博客访问: 106932415
  • 博文数量: 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博客
  • 博客访问: 106932416
  • 博文数量: 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博客
  • 博客访问: 106932417
  • 博文数量: 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博客
  • 博客访问: 106932418
  • 博文数量: 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博客
  • 博客访问: 106932419
  • 博文数量: 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博客
  • 博客访问: 106932420
  • 博文数量: 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博客
  • 博客访问: 106932421
  • 博文数量: 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博客
  • 博客访问: 106932422
  • 博文数量: 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博客
  • 博客访问: 106932423
  • 博文数量: 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博客
  • 博客访问: 106932424
  • 博文数量: 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博客
  • 博客访问: 106932426
  • 博文数量: 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博客
  • 博客访问: 106932427
  • 博文数量: 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博客
  • 博客访问: 106932428
  • 博文数量: 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博客
  • 博客访问: 106932415
  • 博文数量: 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博客
  • 博客访问: 106932431
  • 博文数量: 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博客
  • 博客访问: 106932432
  • 博文数量: 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博客
  • 博客访问: 106932433
  • 博文数量: 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博客
  • 博客访问: 106932434
  • 博文数量: 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博客
  • 博客访问: 106932435
  • 博文数量: 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博客
  • 博客访问: 106932436
  • 博文数量: 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博客
  • 博客访问: 106932437
  • 博文数量: 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博客
  • 博客访问: 106932438
  • 博文数量: 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博客
  • 博客访问: 106932439
  • 博文数量: 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博客
  • 博客访问: 106932440
  • 博文数量: 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博客
  • 博客访问: 106932441
  • 博文数量: 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博客
  • 博客访问: 106932442
  • 博文数量: 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博客
  • 博客访问: 106932443
  • 博文数量: 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博客
  • 博客访问: 106932434
  • 博文数量: 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博客
  • 博客访问: 106932445
  • 博文数量: 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博客
  • 博客访问: 106932446
  • 博文数量: 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博客
  • 博客访问: 106932447
  • 博文数量: 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博客
  • 博客访问: 106932448
  • 博文数量: 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博客
  • 博客访问: 106932449
  • 博文数量: 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博客
  • 博客访问: 106932450
  • 博文数量: 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博客
  • 博客访问: 106932451
  • 博文数量: 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博客
  • 博客访问: 106932452
  • 博文数量: 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博客
  • 博客访问: 106932453
  • 博文数量: 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博客
  • 博客访问: 106932454
  • 博文数量: 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博客
  • 博客访问: 106932455
  • 博文数量: 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博客
  • 博客访问: 106932456
  • 博文数量: 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博客
  • 博客访问: 106932457
  • 博文数量: 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博客
  • 博客访问: 106932458
  • 博文数量: 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博客
  • 博客访问: 106932449
  • 博文数量: 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博客
  • 博客访问: 106932460
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:41

学习基本概念

developerWorks



在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

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

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

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

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

    或者

    DELETE FROM staff WHERE id = 100

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

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





回页首


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

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

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

UPDATE [OR DELETE] ... WHERE CURRENT OF 

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

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

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

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

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

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





回页首


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

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

EXEC SQL OPEN C0;

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

EXEC SQL CLOSE C0;

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

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


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

阅读(110785) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

阅读(110784) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

阅读(110783) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

阅读(110782) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

阅读(110781) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

阅读(110780) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

阅读(110779) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

阅读(110778) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

阅读(110777) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

阅读(110776) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

阅读(110775) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


在 SQL 程序中何时使用游标

游标(cursor)是用于操纵 DB2 查询返回的多行结果集的一种机制。 在以下两种情况下,需要使用游标:

  • 查询返回不止一行。
    含 INTO 子句的 SELECT 语句很容易编写,但是这种语句只允许返回一行。在一条 SELECT 语句中不存在允许直接处理多个行的子句,所以必须使用游标。

  • 当您想要更新或删除一个或多个行,但是首先需要检查它们的内容时,需要使用游标。
    更新或删除行的最简单的方法是使用像下面这样的语句:

    UPDATE staff SET salary = salary * 1.10 WHERE id = 100

    或者

    DELETE FROM staff WHERE id = 100

    然而,这些叫做 searched 更新或删除的语句,在更新或删除之前不允许程序检查行的内容。这时可以考虑使用一个游标,结合使用一条 positioned 更新或删除语句。后一种方法也称 Update Where Current Of 和 Delete Where Current Of,其中 Current Of 是指游标当前所处在的行。

要使用游标,首先必须声明它,然后打开它,接着从中获取行,每次只能获取一行,再(可选地)更新或删除游标所处在的那一行,最后关闭该游标。在本节和后面的小节中,可以看到更多细节和例子。





回页首


游标支持和术语会因 DB2 编程接口的不同而不同。让我们简略地看一下这些不同点。然后,在 操纵游标 小节中,还可以看到嵌入式 SQL 的一些例子。

对游标的基本支持是由 SQL 语言本身通过 DECLARE CURSOROPENFETCHCLOSE 语句提供的。

通过以下语法,可以执行 positioned 更新和删除:

UPDATE [OR DELETE] ... WHERE CURRENT OF 

不同的接口以不同的方式建立 SQL 游标支持。传统编程语言,例如 C、C++ 和 COBOL,支持在静态和动态嵌入式 SQL 中显式地声明和使用游标。在这些语言中,能单向地一次一行地对行进行处理。

SQL 过程语言对游标的支持非常类似于 C,不过它增加了 WITH RETURN 子句,以支持将结果集返回给存储过程的调用者。

在 DB2 CLI 中,游标不是显式地声明的,当调用 SQLExecute()SQLExecDirect() 函数时,CLI 自动创建游标。在游标支持的基础上,CLI 提供了附加的功能,例如向后滚动的功能,一次检索一组行的功能,以及按多行向前移动的功能。

在 JDBC 中,游标是在创建 ResultSet 对象时自动创建的。JDBC 也提供了类似于 CLI 的附加功能。

SQLJ 的游标支持实际上是 JDBC 和 SQL 中游标支持的混合体,但是在 SQLJ 中,游标的等同物被称作迭代器(iterator)

一些交互式工具,例如 DB2 Command Line Processor (CLP) 和 Control Center,不允许直接使用游标。但是,这些工具本身会使用游标。当通过 CLP 执行一条 SELECT 语句时,或者在 Control Center 中向一个表请求样本内容时,都要使用游标来返回行。





回页首


在更深入地讨论游标之前,首先看看静态嵌入式 SQL(一个 C 程序)中的一个非常简单的游标。

EXEC SQL DECLARE C0 CURSOR FOR SELECT DEPTNUMB, DEPTNAME FROM ORG;

EXEC SQL OPEN C0;

EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
WHILE (SQLCA.SQLCODE != 100)  /* CONTINUE UNTIL THE END OF THE RESULT SET */
{
PRINTF("    %8D %-14S\N", DEPTNUMB, DEPTNAME);
EXEC SQL FETCH C0 INTO :DEPTNUMB, :DEPTNAME;
}

EXEC SQL CLOSE C0;

这段代码打印 org 表中每个部门的编号和名称。DECLARE CURSOR 语句提供所使用的查询,OPEN 语句准备查询的结果集。FETCH 语句重复地用于将结果集中各列的值移到程序变量中,一次移一行,直到到达结果集的结尾处 (SQLCODE = +100),此时游标关闭。

阅读(110774) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~