DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346713
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346714
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346715
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346716
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346717
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346718
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346719
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346720
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346721
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346722
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346723
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346714
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346725
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346726
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346727
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346728
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346729
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346730
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346731
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346732
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346733
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346734
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346735
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346736
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346737
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346738
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346729
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346740
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346741
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346742
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346743
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346744
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346745
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346746
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346747
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346748
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346749
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346750
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346751
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

将定制的和复杂的业务逻辑集成到 SQL 语句中

DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(4)-sdccf-ChinaUnix博客

Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

博客访问： 91346752
博文数量： 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 考试）认证指南，第 9 部分: 用户定义的例程(4)

分类：

2008-05-31 23:49:01

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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

外部用户定义函数

通过以函数的形式引用外部程序，SQL 语句可以变得很强大。通过使用 C 和 Java 等编程语言编写函数，可以执行非常高级的任务，例如字符串操纵，这些任务原本可能需要在一个 SQL UDF 中使用多个（看上去比较费解的）SQL 语句。此外，还可以在这些编程语言中处理外部数据源或者执行外部动作。

外部函数可以定义为以两种不同的模式运行，一种是 NOT FENCED 模式 —— 也就是说在数据库引擎中运行，另一种是 FENCED 模式 —— 也就是说在数据库引擎之外的内存中运行。使用 NOT FENCED 函数的优点是，它与数据库引擎共享内存，可以更快地与数据库引擎通信。但是，如果没有正确地编写 NOT FENCED 函数，那么可能出现内存漏洞。如果是这样，内存漏洞会开始覆盖与 DB2 引擎相关的内存，这会造成一些恶劣的影响，例如使 DB2 崩溃。如果是编写 C 或 C++ 函数，那么强烈建议将函数编写为 FENCED 函数，并且在决定将它们重新创建为 NOT FENCED 之前进行大量的练习。

清单 19 显示了注册外部函数的一个简化语法图：

                    
>>-CREATE FUNCTION--function-name------------------------------->
 
>--(--+----------------------------------------------------+--)-->
      | .-,----------------------------------------------. |
      | V                                                | |
      '---+----------------+--data-type1--+------------+-+-'
          '-parameter-name-'              '-AS LOCATOR-'
 
>--*------------------------------------------------------------>
 
>--RETURNS--+-data-type2--+------------+------------------------+-->
            |             '-AS LOCATOR-'                        |
            '-data-type3--CAST FROM--data-type4--+------------+-'
                                                 '-AS LOCATOR-'
 
>--*--+-------------------------+--*---------------------------->
      '-SPECIFIC--specific-name-'
 
>--EXTERNAL--+----------------------+--*------------------------>
             '-NAME--+-'string'---+-'
                     '-identifier-'
                    
>--LANGUAGE--+-C----+-------*----------------------------------->
             +-JAVA-+
             +-CLR--+
             '-OLE--'
                                       .-NOT DETERMINISTIC-.
>--PARAMETER STYLE--+-DB2GENERAL-+--*--------------------------->
                    +-JAVA-------+
                    '-SQL--------'
                                        .-NOT DETERMINISTIC-.
>--+------------------------------+--*--+-------------------+--->
   '-PARAMETER CCSID--+-ASCII---+-'     '-DETERMINISTIC-----'
                      '-UNICODE-'
 
      .-FENCED------------------------.
>--*--+-------------------------------+--*---------------------->
      +-FENCED--*--+-THREADSAFE-----+-+
      |            '-NOT THREADSAFE-' |
      |                .-THREADSAFE-. |
      '-NOT FENCED--*--+------------+-'
 
   .-RETURNS NULL ON NULL INPUT-.     .-READS SQL DATA-.
>--+----------------------------+--*--+----------------+--*----->
   '-CALLED ON NULL INPUT-------'     +-NO SQL---------+
                                      '-CONTAINS SQL---'
 
   .-STATIC DISPATCH-.     .-EXTERNAL ACTION----.
>--+-----------------+--*--+--------------------+--*------------>
                           '-NO EXTERNAL ACTION-'
 
   .-NO SCRATCHPAD----------.     .-NO FINAL CALL-.
>--+------------------------+--*--+---------------+--*---------->
   |             .-100----. |     '-FINAL CALL----'
   '-SCRATCHPAD--+--------+-'
                 '-length-'
 
                             .-NO DBINFO-.
>--+-------------------+--*--+-----------+--*------------------->
   +-ALLOW PARALLEL----+     '-DBINFO----'
   '-DISALLOW PARALLEL-'

在上一节中，您已经看到了 CREATE FUNCTION 语句中最重要的组成部分。其实，还有一些组成部分是外部函数特有的：

LANGUAGE: 指定用于编写函数的语言。可用于编写外部函数的语言有 C、Java 语言、CLR 和 OLE。
PARAMETER STYLE: 该子句用于指定函数传递参数和返回值的约定。
EXTERNAL ACTION: 确定该函数是否可以执行外部动作。
SCRATCHPAD: 高速暂存（scratchpad）用作在函数调用间隙存储数据的一个内存块。
FINAL CALL: 用于释放函数所占用的内存，并执行其他清理动作。

要了解更多关于 CREATE FUNCTION 语句的这些子句和其他子句的信息，请参阅 DB2 文档。

清单 20 是一个注册名为 NTEST1 的标量用户定义函数（用 C 编写）的例子：

                    
CREATE FUNCTION ntest1 (SMALLINT)
    RETURNS SMALLINT
    EXTERNAL NAME 'ntest1!nudft1'
    LANGUAGE C
    PARAMETER STYLE SQL
    DETERMINISTIC
    NOT FENCED
    NULL CALL
    NO SQL 
    NO EXTERNAL ACTION

该函数接收一个 SMALLINT 类型的输入参数，并返回一个 SMALLINT 值。函数体中没有使用 SQL。需要注意的是，无论函数中实际的 C 代码是否经过正确的编译，产生的库（DLL）文件是否被放在适当的位置，上面的 CREATE FUNCTION 语句都会成功地执行。如果库文件没有放在适当的位置，此时若执行上述函数，虽然函数能注册成功，但是会收到一个错误，表明没有发现函数库。由于这个原因，在使用外部函数时，必须按照正确的步骤编译函数，将函数库放入适当的位置，并使用 CREATE FUNCTION 语句注册函数。欲获得更多关于这些步骤的信息，请参阅 DB2 文档。

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

0

上一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(3)

下一篇：DB2 9 应用开发（733 考试）认证指南，第 9 部分: 用户定义的例程(5)

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

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

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

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