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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:17:13

学习基本概念

developerWorks



函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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


函数和表达式

数据库函数 是一组输入数据值与一组结果值之间的一种关系。有两种类型的函数:内置(built-in)函数和用户定义(user-defined)函数。

  • 内置 SQL 函数是数据库管理器提供的。它们提供单一的结果值,被标识为 SYSIBM 模式的一部分。内置 SQL 函数的例子包括 AVG 之类的列函数、+ 之类的操作符函数、DECIMAL 之类的类型覆盖函数以及其他函数,比如 SUBSTR

  • 用户定义函数(UDF)是在 SYSCAT.FUNCTIONS 中注册到数据库的函数(使用 CREATE FUNCTION 语句。UDF 决不不是 SYSIBM 模式的一部分。数据库管理器在一个名为 SYSFUN 的模式中提供了那样一组函数。

DB2 允许用户和应用程序开发人员将他们自己的函数定义应用于数据库引擎中,以扩展数据库系统的功能。与从数据库中检索行,然后在所检索到的数据上应用那些函数的应用程序相比,基于 UDF 的应用程序有更好的性能。通过扩展数据库函数还可以让数据库在应用程序所使用的引擎中使用相同的函数,从而加强应用程序与数据库之间的协作。函数的使用有助于提高应用程序开发人员的生产率,因为这样更接近面向对象的思想。例如,您可能以美元为单位存储一个产品的价格,但是又希望某个应用程序以英镑为单位引用该价格。那么可以使用一个函数来解决这个问题:

SELECT UNIT_PRICE, CURRENCY('UK',UNIT_PRICE) FROM PRODUCT WHERE PRODUCT_ID = ? 





回页首


可以用 C/C++、Java 语言或 OLE 创建函数。函数可以以 FENCEDNOT-FENCED 模式运行。在迁移到 NOT-FENCED 模式之前,应该用 FENCED 模式开发函数。NOT-FENCED 进程更快一些,因为它使用 DB2 代理内存,而 FENCED 进程在它自己的 db2udf 进程中运行。FENCED 进程使用共享内存与调用代理通信。FENCED 函数存储在 sqllib/function 中,而 NOT-FENCED 则存储在 sqllib/unfenced 中。





回页首


现在来看一些 SQL 函数的例子。第一个例子从一个表中选择所有书的标题和价格。如果该书的价格为 NULL,则将其价格显示为 0.00

SELECT TITLE, COALESCE(PRICE, 0.00) AS PRICE 
FROM TITLES;

接下来的例子返回的结果是公司的名称以及公司名称中所含的字符数:

SELECT COMPANYNAME, LENGTH(COMPANYNAME)
FROM CUSTOMERS

现在看看如何返回每个作者的名字(first name)最右边的 5 个字符:

SELECT RIGHT(AU_FNAME, 5) 
FROM AUTHORS

下一个例子使用 project 表,将宿主变量 AVERAGE (decimal(5,2)) 设置为名为 D11 的部门(DEPTNO)中项目的平均工资水平(PRSTAFF)。

SELECT AVG(PRSTAFF)
INTO :AVERAGE
FROM PROJECT
WHERE DEPTNO = 'D11'

DB2 SQL Reference 手册中还定义了很多其他的 SQL 函数。如果 DB2 没有提供适当的函数,您总是可以编写自己的 SQL 函数。





回页首


公共表表达式 是一个本地临时表,可以在一条 SQL 语句中引用多次。这个临时表只能存在于定义它的 SQL 语句的生命周期内。每次公共表表达式被引用时,其结果都是相同的。临时表是在 SQL 语句中用 WITH 子句定义的。下面是具体的语法:

WITH  AS (  FROM  

是数据库中的一个表,也可以是由一个包括 WITH 子句的 SQL 语句定义的 。 下面是一个例子:

WITH PROD_QUANTITY  AS
(SELECT PRODUCT_ID,  SUM (QUANTITY) AS  QUANTITY
    FROM CUSTOMER_ORDER_ITEM
    GROUP BY PRODUCT_ID),

  TOTALS  AS
(SELECT  -1 AS PRODUCT_ID, SUM(QUANTITY) AS TOTAL)

SELECT PRODUCT_ID, QUANTITY  
 FROM PROD_QUANTITY
UNION
SELECT PRODUCT_ID, TOTALS
FROM TOTALS
ORDER BY 1 DESC

在上述例子中,prod_quantity 被定义为一个公共表表达式。它与一个名为 totals 的公共表表达式一起使用。最终的 SELECT 语句将从两个公共表表达式中进行选择。

下面看另一个例子:

WITH
  PAYLEVEL AS                                                 
    (SELECT EMPNO, EDLEVEL, YEAR(HIREDATE) AS HIREYEAR,           
        SALARY+BONUS+COMM AS TOTAL_PAY                                     
        FROM EMPLOYEE                                                         
        WHERE EDLEVEL > 16),                                                       

  PAYBYED (EDUC_LEVEL, YEAR_OF_HIRE, AVG_TOTAL_PAY) AS         
    (SELECT EDLEVEL, HIREYEAR, AVG(TOTAL_PAY)                  
         FROM PAYLEVEL                                            
         GROUP BY EDLEVEL, HIREYEAR)

  SELECT EMPNO, EDLEVEL, YEAR_OF_HIRE, TOTAL_PAY, DECIMAL(AVG_TOTAL_PAY,7,2)
    FROM PAYLEVEL, PAYBYED                                             
    WHERE EDLEVEL =  EDUC_LEVEL                                        
        AND HIREYEAR=  YEAR_OF_HIRE                              
        AND TOTAL_PAY < AVG_TOTAL_PAY                        

这个公共表表达式包含了 PAYLEVEL。这个结果表包括员工编号、该员工被雇年份、该员工的总工资以及该员工的受教育程度。只需要包括受教育程度大于 16 的那些员工的记录。

该列表还包括一个名为 PAYBYED(“pay by education” 的缩写)的公共表表达式。它通过使用 PAYLEVEL 表来确定受教育程度、被雇年份和同年被雇的具有同等受教育程度的员工的平均工资。由这个表中得到的列的列名(例如 EDUC_LEVEL)与选择列表中使用的列名不同。

最后,我们得到能够产生所需结果的实际查询。该查询连接两个表(PAYLEVELPAYBYED),确定工资低于同年雇用的所有员工平均工资的员工。注意,PAYBYED 是基于 PAYLEVEL 的,所以在整个语句中,PAYLEVEL 实际上被访问了两次。在这两次中,计算查询时都用到了同一组行。

在定义一个公共表表达式之后,就可以像使用其他表一样 SQL 语句中使用它。可以任意次地使用公共表表达式。甚至可以在之前创建的公共表表达式的基础上,再创建一个公共表表达式。

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