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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651482
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651483
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651484
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651485
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651486
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651487
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651488
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651479
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651490
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651491
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651493
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651494
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651496
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651497
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651498
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651499
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651500
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651501
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651502
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651503
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651494
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651505
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651506
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651507
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651508
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651509
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651510
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651511
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651512
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651513
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651514
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651515
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651516
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651517
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651518
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651509
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651520
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651521
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651522
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

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

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

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 105651523
博文数量： 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 部分: 高级编程(2)

分类：

2008-05-31 23:43:12

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

以下是一个示例：

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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

用户定义的数据类型和数据类型转换

用户定义的类型（常常简称为 UDT）是根据其他 DB2 数据类型（比如 INTEGER 或 CHAR 数据类型）创建的数据类型。UDT 甚至可以基于其他 UDT。

UDT 用于建立变量的上下文。它们允许追踪如何在应用程序中使用对象。还可以定义不同数据类型和 UDT 之间的关系。

我们来考虑一个简单的示例。假设您有一个应用程序用来确定美国和加拿大的商店之间的最佳路线。为了实现这个功能，必须同时使用公制和英制度量的长度。您可能不知道表中存储的数据是以千米还是以英里为单位的。可以使用一个 UDT 创建一个 KM 类型，使用另一个 UDT 创建一个 MILES 类型。通过明确地使用这些类型，可以清楚地知道表中存储的是哪种度量方式的数据。还可以编写一个函数，用来自动地将 KM 和 MILES 类型的数据相加。

UDT：KM 与 MILES

可以用 CREATE DISTINCT TYPE 语句创建 UDT。该语句的语法如下：

-CREATE DISTINCT TYPE--distinct-type-name--AS----------------->
   --| source-data-type |--WITH COMPARISONS----------------------|

源数据类型可以是 DB2 所使用的任何标准数据类型，但是 XML 除外。

以下是一些示例：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS

当成功地创建了 UDT 时，DB2 将自动生成标准比较操作符（=、<>、<、<=、> 和 >=）。

创建 UDT 的授权 ID 所持有的特权必须至少包括下列特权之一：

SYSADM 或 DBADM 权力
数据库上的 IMPLICIT_SCHEMA 权力（如果不同类型的模式名不指向现有的模式）
模式上的 CREATEIN 特权（如果不同类型的模式名指向现有的模式）

刚接触 DB2 的开发人员在首次使用 UDT 时常常会造成错误，这是因为 UDT 与常规数据类型交互的方式和彼此之间交互的方式不同。通常，DB2 会自动地进行数据类型的转换，从而允许执行算术或比较操作。但是对于 UDT 则不会如此。

DB2 并不自动地对所有数据类型进行转换。如果数据类型属于同一数据类型组（如图 2 所示），则转换会自动进行。如果它们不属于同一组，就会出现错误。

DB2 数据类型组

例如，以下代码片段在 DB2 中会失败：

empno = CHAR(6)  {but the data is always numeric}
SQL String: SELECT (empno + 1) AS new_emp_no FROM employee

这个语句将失败，因为无法将整数 “1” 与字符数据相加，即使该数据是一个数字的字符串表示。

想要使用不同的 UDT 或数据类型进行比较或执行算术操作，可以使用 CAST 指令将它们转换成同一数据类型。以下是其语法：

CAST--(--objectName--AS--target-data-type--)----|

以下是一个示例：

CAST (empno AS INTEGER)

让我们再看几个示例。首先，创建两个不同的类型和一个使用它们的表：

CREATE DISTINCT TYPE km AS INTEGER WITH COMPARISONS;
CREATE DISTINCT TYPE miles AS INTEGER WITH COMPARISONS;

CREATE TABLE cityInfo (
	cityName   CHAR(20),
	width_k    KM         NOT NULL,
	width_m    MILES      NOT NULL
);

下面的 SQL 语句会成功执行，因为 WHERE 子句中进行比较的数据类型正确地转换为相同的数据类型。这个 SQL 语句将整数 “10” 转换成 KM 类型以便进行比较。

SELECT cityName
FROM cityInfo
WHERE width_k > km(10)

现在，让我们修改上面的语句来模拟一个常见的错误。下面的语句不会成功，因为 DB2 不知道如何比较 MILES 和 KM 数据类型：

SELECT cityName
FROM cityInfo
WHERE width_k > width_m

但是，下面的语句将成功执行，因为这两种数据类型都被转换成 INTEGER 类型。

SELECT cityName
FROM cityInfo
WHERE CAST(width_k AS INTEGER) > CAST(width_m AS INTEGER)

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

0

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

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

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

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

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

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