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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:28:09

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

developerWorks



嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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


嵌入式 SQL 编程简介

结构化查询语言(Structured Query Language,SQL)是用于操纵数据库对象及其所包含数据的标准化语言。SQL 由多个不同的语句构成,这些语句用来定义、更改和销毁数据库对象,以及添加、修改、删除和检索数据值。但是,SQL 是非过程的,所以它不是一种通用的编程语言。(SQL 语句是由 DB2 Database Manager 而不是操作系统来执行的。)因此,常常通过将高级编程语言的决策和序列控制与数据存储、操纵和检索等 SQL 功能组合起来,开发出数据库应用程序。可以用多种方法将 SQL 与高级编程语言结合起来,但最简单的方法是将 SQL 语句直接嵌入用于创建应用程序的高级编程语言源代码文件中。该技术被称作嵌入式 SQL 编程(embedded SQL programming)。

使用嵌入式 SQL 开发应用程序的缺点之一是,高级编程语言编译器不认识在源代码文件中嵌入的 SQL 语句,因而也无法解释它们。因此,在对包含嵌入式 SQL 的源代码文件进行编译和链接以产生可执行应用程序之前,必须对它们进行预处理(使用称作预编译(precompiling) 的过程)。为了便于进行预处理,在高级编程语言源代码文件中,嵌入的每个 SQL 语句必须以关键字 EXEC SQL 为前缀,并以分号(在 C/C++ 中)或关键字 END_EXEC (在 COBOL 中)结束。由一个称为 SQL 预编译器的特殊工具执行预处理;当 SQL 预编译器碰到 EXEC SQL 关键字时,就用特定于 DB2 的函数调用替换随后的文本(直到发现分号(;)或关键字 END-EXEC),从而将遇到的 SQL 语句转发给 DB2 Database Manager 进行处理。同样,DB2 Database Manager 也无法直接使用高级编程语言的变量。相反,它必须使用称为宿主变量(host variable)的特殊变量,在应用程序和数据库之间移动数据(我们将在 声明宿主变量 一节中更加深入地了解宿主变量)。宿主变量看上去与任何其他高级编程语言变量一样;为了加以区分,必须在名为声明段(declare section)的专用区域中定义它们。另外,为了让 SQL 预编译器区分宿主变量和 SQL 语句中的其他文本,对于宿主变量的所有引用都必须以冒号(:)开头。





回页首


静态 SQL 语句是一种可以在开发时在应用程序中进行硬编码的 SQL 语句,因为关于它的结构和要与之交互的对象(例如表、列和数据类型)的信息事先就知道。由于在开发时就知道静态 SQL 语句的细节,所以分析语句以及选择最优化的数据访问计划来执行该语句等工作由 DB2 优化器在开发过程中执行。由于其操作形式已存储在数据库中(作为一个包),无需在应用程序运行时生成,所以静态 SQL 语句可以快速执行。

该方法的缺点是,在执行之前,必须准备好所有的静态 SQL 语句(换言之,必须生成其访问计划并存储在数据库中)。而且,在运行时不能更改静态 SQL 语句,而且每个使用静态 SQL 的应用程序都必须将其操作包绑定到应用程序将要与之交互的每一个数据库上。此外,因为静态 SQL 应用程序需要提前了解数据库对象,所以在开发应用程序之后修改这些对象可能产生意想不到的结果。

以下是静态 SQL 语句的示例:

  SELECT COUNT(*) FROM employee

  UPDATE employee SET lastname = 'Jones' WHERE empid = '001'

  SELECT MAX(salary), MIN(salary) INTO :MaxSalary, :MinSalary FROM employee
        

静态 SQL 语句通常较适合于对一组已知的数据库对象执行预定义操作的高性能应用程序。





回页首


虽然静态 SQL 语句非常容易包含在应用程序中,但其使用有些受限制,因为必须事先知道它们的格式。而动态 SQL 语句要灵活得多,因为它们可以在应用程序运行时进行构造;关于动态 SQL 语句的结构以及要与之进行交互的对象的信息不必事先知道。此外,因为动态 SQL 语句没有预编码的固定格式,所以可以更改它们所引用的数据对象,而不会影响语句(只要语句引用的对象没有被删除)。

尽管动态 SQL 语句通常比静态 SQL 语句更加灵活,但是将其包含在应用程序中的过程常常更为复杂。因为分析语句并选择最优化的数据访问计划等工作是在应用程序运行时执行的(同样由 DB2 优化器完成),所以动态 SQL 语句的执行时间比等效的静态 SQL 更长。(由于动态 SQL 语句可以利用在应用程序运行时获得的数据库统计信息,所以也存在动态 SQL 语句比等效的静态 SQL 语句执行更快的情况,但是那些都是例外而非一般情况。)

以下是动态 SQL 语句的示例:

 SELECT COUNT(*) FROM ?
	
 INSERT INTO EMPLOYEES VALUES (?, ?)
	
 DELETE FROM DEPARTMENT WHERE DEPTID = ?
        

动态 SQL 语句通常较适合于与快速更改的数据库进行交互或者允许用户定义和执行特定查询的应用程序。

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