Chinaunix首页 | 论坛 | 博客
  • 博客访问: 103777397
  • 博文数量: 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博客
  • 博客访问: 103777398
  • 博文数量: 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博客
  • 博客访问: 103777399
  • 博文数量: 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博客
  • 博客访问: 103777400
  • 博文数量: 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博客
  • 博客访问: 103777401
  • 博文数量: 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博客
  • 博客访问: 103777402
  • 博文数量: 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博客
  • 博客访问: 103777403
  • 博文数量: 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博客
  • 博客访问: 103777394
  • 博文数量: 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博客
  • 博客访问: 103777405
  • 博文数量: 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博客
  • 博客访问: 103777406
  • 博文数量: 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博客
  • 博客访问: 103777407
  • 博文数量: 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博客
  • 博客访问: 103777408
  • 博文数量: 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博客
  • 博客访问: 103777409
  • 博文数量: 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博客
  • 博客访问: 103777410
  • 博文数量: 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博客
  • 博客访问: 103777411
  • 博文数量: 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博客
  • 博客访问: 103777412
  • 博文数量: 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博客
  • 博客访问: 103777413
  • 博文数量: 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博客
  • 博客访问: 103777414
  • 博文数量: 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博客
  • 博客访问: 103777415
  • 博文数量: 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博客
  • 博客访问: 103777416
  • 博文数量: 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博客
  • 博客访问: 103777417
  • 博文数量: 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博客
  • 博客访问: 103777418
  • 博文数量: 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博客
  • 博客访问: 103777409
  • 博文数量: 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博客
  • 博客访问: 103777420
  • 博文数量: 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博客
  • 博客访问: 103777421
  • 博文数量: 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博客
  • 博客访问: 103777422
  • 博文数量: 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博客
  • 博客访问: 103777423
  • 博文数量: 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博客
  • 博客访问: 103777424
  • 博文数量: 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博客
  • 博客访问: 103777425
  • 博文数量: 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博客
  • 博客访问: 103777426
  • 博文数量: 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博客
  • 博客访问: 103777427
  • 博文数量: 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博客
  • 博客访问: 103777428
  • 博文数量: 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博客
  • 博客访问: 103777429
  • 博文数量: 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博客
  • 博客访问: 103777430
  • 博文数量: 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博客
  • 博客访问: 103777431
  • 博文数量: 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博客
  • 博客访问: 103777432
  • 博文数量: 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博客
  • 博客访问: 103777433
  • 博文数量: 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博客
  • 博客访问: 103777424
  • 博文数量: 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博客
  • 博客访问: 103777435
  • 博文数量: 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博客
  • 博客访问: 103777436
  • 博文数量: 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博客
  • 博客访问: 103777437
  • 博文数量: 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博客
  • 博客访问: 103777438
  • 博文数量: 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博客
  • 博客访问: 103777439
  • 博文数量: 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博客
  • 博客访问: 103777440
  • 博文数量: 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博客
  • 博客访问: 103777441
  • 博文数量: 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博客
  • 博客访问: 103777442
  • 博文数量: 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博客
  • 博客访问: 103777443
  • 博文数量: 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博客
  • 博客访问: 103777444
  • 博文数量: 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博客
  • 博客访问: 103777445
  • 博文数量: 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博客
  • 博客访问: 103777446
  • 博文数量: 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博客
  • 博客访问: 103777447
  • 博文数量: 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博客
  • 博客访问: 103777448
  • 博文数量: 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),此时游标关闭。

阅读(110230) | 评论(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),此时游标关闭。

阅读(110229) | 评论(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),此时游标关闭。

阅读(110228) | 评论(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),此时游标关闭。

阅读(110227) | 评论(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),此时游标关闭。

阅读(110226) | 评论(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),此时游标关闭。

阅读(110225) | 评论(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),此时游标关闭。

阅读(110224) | 评论(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),此时游标关闭。

阅读(110223) | 评论(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),此时游标关闭。

阅读(110222) | 评论(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),此时游标关闭。

阅读(110221) | 评论(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),此时游标关闭。

阅读(110220) | 评论(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),此时游标关闭。

阅读(110219) | 评论(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),此时游标关闭。

阅读(110218) | 评论(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),此时游标关闭。

阅读(110217) | 评论(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),此时游标关闭。

阅读(110216) | 评论(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),此时游标关闭。

阅读(110215) | 评论(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),此时游标关闭。

阅读(110214) | 评论(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),此时游标关闭。

阅读(110213) | 评论(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),此时游标关闭。

阅读(110212) | 评论(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),此时游标关闭。

阅读(110211) | 评论(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),此时游标关闭。

阅读(110210) | 评论(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),此时游标关闭。

阅读(110209) | 评论(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),此时游标关闭。

阅读(110208) | 评论(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),此时游标关闭。

阅读(110207) | 评论(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),此时游标关闭。

阅读(110206) | 评论(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),此时游标关闭。

阅读(110205) | 评论(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),此时游标关闭。

阅读(110204) | 评论(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),此时游标关闭。

阅读(110203) | 评论(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),此时游标关闭。

阅读(110202) | 评论(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),此时游标关闭。

阅读(110201) | 评论(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),此时游标关闭。

阅读(110200) | 评论(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),此时游标关闭。

阅读(110199) | 评论(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),此时游标关闭。

阅读(110198) | 评论(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),此时游标关闭。

阅读(110197) | 评论(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),此时游标关闭。

阅读(110196) | 评论(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),此时游标关闭。

阅读(110195) | 评论(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),此时游标关闭。

阅读(110194) | 评论(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),此时游标关闭。

阅读(110193) | 评论(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),此时游标关闭。

阅读(110192) | 评论(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),此时游标关闭。

阅读(110191) | 评论(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),此时游标关闭。

阅读(110190) | 评论(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),此时游标关闭。

阅读(110189) | 评论(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),此时游标关闭。

阅读(110188) | 评论(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),此时游标关闭。

阅读(110187) | 评论(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),此时游标关闭。

阅读(110186) | 评论(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),此时游标关闭。

阅读(110185) | 评论(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),此时游标关闭。

阅读(110184) | 评论(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),此时游标关闭。

阅读(110183) | 评论(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),此时游标关闭。

阅读(110182) | 评论(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),此时游标关闭。

阅读(110181) | 评论(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),此时游标关闭。

阅读(110180) | 评论(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),此时游标关闭。

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