DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792191
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792192
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792193
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792194
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792195
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792196
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792197
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792198
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792199
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792200
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792201
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792202
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792203
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792194
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792205
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792206
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792207
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792208
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792209
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792210
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792211
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792212
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792213
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792214
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792215
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792216
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792217
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792218
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792209
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792220
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792221
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792222
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792223
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792224
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792225
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792226
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792227
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792228
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792229
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

用户定义的数据类型、并发性考虑因素等等

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 90792230
博文数量： 19283
博客积分： 9968
博客等级：上将
技术积分： 196062
用户组：普通用户
注册时间： 2007-02-07 14:28

文章分类

全部博文（19283）

香文化（0）
CU技术专题（2443）

Linux酷软（214）

tmp（0）

PostgreSQL（93）

Solaris（383）

AIX（173）

SCOUNIX（575）

DB2（1005）
涂鸦（9）
编程开发（1573）

Shell（386）

C/C++（1187）
数据库（6458）

MySQL（1750）

Sybase（465）

Oracle（3695）

Informix（548）
操作系统（8627）

HP-UX（0）

IBM AIX（2）

Sun Solaris（0）

BSD（1）

Linux（8597）

SCO UNIX（23）
未分配的博文（173）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友

最近访客

推荐博文

DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(4)

分类：

2008-05-31 23:44:12

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364512) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364511) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364510) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364509) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364508) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364507) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364506) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364505) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364504) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364503) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364502) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364501) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364500) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364499) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364498) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364497) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364496) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364495) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364494) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364493) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364492) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364491) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364490) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364489) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364488) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364487) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364486) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364485) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364484) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364483) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364482) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364481) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364480) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364479) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364478) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364477) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364476) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364475) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364474) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

复合 SQL

SQL 语句通常要逐句执行。这使得编程更加容易，但是也意味着必须在客户机和服务器之间传送每个语句和每个结果集。为了减少应用程序所生成的网络流量，可以将多个 SQL 语句编为一个组。这个组则称作复合 SQL（compound SQL）。复合 SQL 通常用在服务器端对象中，比如存储过程和用户定义的函数，也用在嵌入式 SQL 应用程序中。

有两种类型的复合 SQL：原子的（atomic）和非原子的（non-atomic）。

对于原子的 SQL，当所有子语句成功完成时，或者当某个子语句失败时，应用程序会从数据库管理器接收一个响应。如果一个子语句失败，那么会将整个组视作失败，该组中对数据库所做的任何更改都被回滚。

对于非原子的 SQL，当所有子语句完成时，应用程序会从数据库管理器接收一个响应。无论前一子语句是否成功完成，组中的每个子语句都会执行。只有在回滚包含非原子复合 SQL 的工作单元时，才可以回滚该语句组。

使用复合 SQL 有一些优点：

可以减少网络流量，因为只会传送最初的 SQL 块和最终的结果集。
可以提高应用程序的整体速度，因为更多工作是在服务器而不是客户机上执行的。

但是，使用复合 SQL 也有一些缺点：

只能从执行的整个 SQL 语句组接收一条错误消息。
如果发生错误，就无法判断是哪个 SQL 语句失败了。

图 3 是一个使用复合 SQL 造成网络流量下降的示例。更多的线表示更大的网络流量。网络流量的下降完全依靠复合 SQL 中 SELECT、INSERT、UPDATE 和 DELETE 语句的平衡。

网络流量：用和不用复合 SQL

在下列几种情况下，建议使用复合 SQL：

将在 SQL 语句块中来回发送大量数据。使用复合 SQL 可以减少网络流量。
您有一个反应迟缓的客户机，但是希望利用高速的服务器。使用复合 SQL 可以确保在服务器上进行处理，并仅将最后的结果发送回客户机。

复合语句块以 BEGIN 关键字开始，并以 END 关键字结束。以下是一个示例：

BEGIN ATOMIC
    UPDATE employee
        SET salary = salary * 1.1
        WHERE edlevel > 12;

    UPDATE dept
        SET budget = budget * 0.8
        WHERE profitMargin > 10;

    INSERT INTO deptList (empno,salary)
	VALUES (SELECT empno,salary
		 FROM employee WHERE edlevel = 15);
END

如果以上的复合语句在第一个 UPDATE 语句就失败了，将无法判断是哪个语句失败了。构造这个复合语句的优点是，发送给服务器并返回的数据仅仅是 SQL 语句和最后的 SQL 返回码。

阅读(364473) | 评论(0) | 转发(0) |

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 8 部分: 高级编程(5)

给主人留下些什么吧！~~

关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们