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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:30:34

构建与 DB2 进行交互的应用程序

developerWorks



结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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


结束语

本教程介绍了嵌入式 SQL 编程,并带领您完成了开发嵌入式 SQL 应用程序的基本步骤。结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。因为 SQL 是非过程的,所以它不是一种通用的编程语言。因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。

同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量的特殊变量,在应用程序和数据库之间移动数据。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。

为了对数据库执行任何类型的操作,必须首先建立到数据库的连接。在嵌入式 SQL 应用程序中,通过执行 CONNECT SQL 语句来建立(某些情况下为终止)数据库连接。在连接过程中,建立连接所需的信息(例如授权 ID 和授权用户相应的口令)将被传递给适当的数据库以进行有效性检验。通常,在应用程序运行时收集该信息,并通过一个或多个宿主变量将其传递给 CONNECT 语句。

嵌入式 SQL 应用程序由静态和动态的 SQL 语句组成。静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。当在应用程序中嵌入静态 SQL 语句时,在遇到它们时就执行。但是,当使用动态 SQL 语句时,则可以用两种方式之一处理它们:

  • 准备和执行:这种方法将 SQL 语句的准备与它的真正执行分隔开,当要重复执行 SQL 语句时,通常使用该方法。当应用程序需要预先知道在执行 SELECT SQL 语句时所产生的结果数据集中存在的列的有关信息时,也使用该方法。SQL 语句 PREPAREEXECUTE 用于以该方式处理动态 SQL 语句。

  • 立即执行:这种方法将 SQL 语句的准备和执行组合成一步,当 SQL 语句只执行一次时,通常使用该方法。当应用程序不需要关于在执行 SQL 语句时将会产生的结果数据集(如果有的话)的附加信息时,也使用该方法。SQL 语句 EXECUTE IMMEDIATE 用于以该方式处理动态 SQL 语句。

当查询向应用程序返回多行时,DB2 使用称为 “游标” 的机制从所产生的结果数据集中检索数据值。DB2 游标指示出结果数据集中的当前位置(例如,当前行),并识别将返回给应用程序的下一个数据行。如果要将游标包含在嵌入式 SQL 应用程序中,就必须依次执行下列步骤:

  1. 声明(定义)一个游标及其类型(只读的或可更新的),并将其与所需的查询关联起来。

  2. 打开游标。这将导致执行相应的查询并产生结果数据集。

  3. 一行行地检索(读取)结果数据集中存储的每一行,直到出现数据结束的条件。

  4. 关闭游标。这个操作导致删除执行相应查询时所产生的结果数据集。

SQLCA 数据结构包含每当执行 SQL 语句时,由 DB2 Database Manager 更新的元素集合。指派给该结构中 sqlcode 元素的值表示该 SQL 语句是执行成功还是失败(值为 0 表示执行成功,正值表示执行成功但带有警告,而负值表示发生了错误)。在执行 SQL 语句之后,嵌入式 SQL 应用程序至少应该立即检查所产生的 sqlcode 值(通常称作 SQL 返回码)。如果 SQL 语句未能按预期执行,就应该通知用户发生了错误或警告;只要条件允许,还应该给他们提供足够的诊断信息,以便他们定位并解决问题。

一旦编写好源代码文件,在创建与 DB2 数据库进行交互的应用程序之前,必须按所示次序执行下列步骤:

  1. 必须对所有包含嵌入式 SQL 语句的源代码文件进行预编译。

  2. 包含嵌入式 SQL 语句的源代码文件一旦经由 SQL 预编译器处理,就必须用高级编程语言编译器来编译所产生的源代码文件(以及所需的其他源代码文件)。

  3. 当成功编译了构建应用程序所需的所有源代码文件之后,必须将产生的目标模块与高级编程语言库以及 DB2 库链接起来,生成可执行的程序。

  4. 如果由 SQL 预编译器处理的文件的包没有绑定到适当的数据库上,就必须使用在预编译过程中产生的绑定文件来绑定它们。使用 DB2 Binder 工具完成绑定过程。

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