Chinaunix首页 | 论坛 | 博客
  • 博客访问: 104673011
  • 博文数量: 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博客
  • 博客访问: 104673012
  • 博文数量: 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博客
  • 博客访问: 104673013
  • 博文数量: 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博客
  • 博客访问: 104673014
  • 博文数量: 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博客
  • 博客访问: 104673015
  • 博文数量: 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博客
  • 博客访问: 104673016
  • 博文数量: 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博客
  • 博客访问: 104673017
  • 博文数量: 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博客
  • 博客访问: 104673018
  • 博文数量: 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博客
  • 博客访问: 104673019
  • 博文数量: 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博客
  • 博客访问: 104673020
  • 博文数量: 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博客
  • 博客访问: 104673021
  • 博文数量: 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博客
  • 博客访问: 104673022
  • 博文数量: 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博客
  • 博客访问: 104673023
  • 博文数量: 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博客
  • 博客访问: 104673014
  • 博文数量: 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博客
  • 博客访问: 104673025
  • 博文数量: 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博客
  • 博客访问: 104673026
  • 博文数量: 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博客
  • 博客访问: 104673027
  • 博文数量: 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博客
  • 博客访问: 104673028
  • 博文数量: 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博客
  • 博客访问: 104673029
  • 博文数量: 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博客
  • 博客访问: 104673030
  • 博文数量: 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博客
  • 博客访问: 104673031
  • 博文数量: 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博客
  • 博客访问: 104673032
  • 博文数量: 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博客
  • 博客访问: 104673033
  • 博文数量: 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博客
  • 博客访问: 104673034
  • 博文数量: 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博客
  • 博客访问: 104673035
  • 博文数量: 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博客
  • 博客访问: 104673036
  • 博文数量: 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博客
  • 博客访问: 104673037
  • 博文数量: 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博客
  • 博客访问: 104673038
  • 博文数量: 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博客
  • 博客访问: 104673029
  • 博文数量: 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博客
  • 博客访问: 104673040
  • 博文数量: 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博客
  • 博客访问: 104673041
  • 博文数量: 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博客
  • 博客访问: 104673042
  • 博文数量: 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博客
  • 博客访问: 104673043
  • 博文数量: 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博客
  • 博客访问: 104673044
  • 博文数量: 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博客
  • 博客访问: 104673045
  • 博文数量: 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博客
  • 博客访问: 104673046
  • 博文数量: 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博客
  • 博客访问: 104673047
  • 博文数量: 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博客
  • 博客访问: 104673048
  • 博文数量: 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博客
  • 博客访问: 104673049
  • 博文数量: 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博客
  • 博客访问: 104673050
  • 博文数量: 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博客
  • 博客访问: 104673051
  • 博文数量: 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博客
  • 博客访问: 104673052
  • 博文数量: 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博客
  • 博客访问: 104673053
  • 博文数量: 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博客
  • 博客访问: 104673044
  • 博文数量: 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博客
  • 博客访问: 104673055
  • 博文数量: 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博客
  • 博客访问: 104673056
  • 博文数量: 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博客
  • 博客访问: 104673058
  • 博文数量: 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博客
  • 博客访问: 104673059
  • 博文数量: 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博客
  • 博客访问: 104673060
  • 博文数量: 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博客
  • 博客访问: 104673061
  • 博文数量: 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博客
  • 博客访问: 104673062
  • 博文数量: 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博客
  • 博客访问: 104673063
  • 博文数量: 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),此时游标关闭。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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