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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914028
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914019
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914030
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914032
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914033
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914034
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914035
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914036
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914037
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914038
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914039
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914040
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914041
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914042
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914043
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914034
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914045
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914046
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914047
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914048
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914049
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914050
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914051
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914052
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914054
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914055
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914056
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914057
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914058
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914049
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914060
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914061
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914062
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914063
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914064
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914065
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914066
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914067
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914068
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914069
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914070
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914071
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914072
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914073
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914064
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914075
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914076
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914077
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914078
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914079
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks

DB2 9 数据库管理(731考试)认证指南,第 3 部分: 数据访问(7)-sdccf-ChinaUnix博客
  • 博客访问: 104914080
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-04-13 14:19:30

developerWorks



强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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


强制实施数据惟一性

许多应用程序都要求表中的数据是惟一的。这种惟一性通常仅应用于行中的某些列,例如员工 ID 或供应商号码等。这样的惟一性保证了仅有一条记录对应单独的一名用户、一个事务或一行。

数据库还需要在表中强制实施惟一行的能力。要实现参照完整性,父表必须具有惟一行,否则,子行和父行之间的关系就无法明确。此外,如果没有这种形式的惟一性和参照完整性,DB2 就无法以星形模式优化对多个表的访问。毫无疑问,具有惟一行的能力对于许多数据库应用程序来说都是至关重要的。







可以通过多种方式保证表中的行惟一:

使用主键。在表创建过程中,您可指定一列为该表的主键:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL PRIMARY KEY, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...
  )

列定义中的 PRIMARY KEY 子句告诉 DB2 自动生成索引,由此索引来强制实施该列的惟一性。此外,整个表仅有一个主键,因此没有其他任何列会包含该子句。若多个列需要保证该行的惟一性,则必须在表定义后加上 PRIMARY KEY 子句:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL, 
  LASTNAME VARCHAR(20) NOT NULL,
  ...,
  PRIMARY KEY (EMPNO, LASTNAME)
  )

使用 UNIQUE 子句。 UNIQUE 子句还可用于生成一行内的惟一值。使用此子句的每一列都将是惟一的:

CREATE TABLE EMPLOYEE 
  (
  EMPNO INT NOT NULL UNIQUE,
  SOCINS CHAR(11) NOT NULL UNIQUE,
  ...,
  )

在本例中,员工号和社会保险号都必须惟一,不应出现具有相同员工号或社会保险号的两个人。为强制实施这种惟一性,DB2 自动生成两个索引,每个对应一列。

使用惟一索引。最后,还可通过使用惟一索引来保证惟一性。使用 CREATE INDEX 命令时,可选择指定值在为其编制索引的一列或多个列中必须惟一:

CREATE UNIQUE INDEX UNIQUE_EMPLOYEE ON EMPLOYEE(EMPNO)

此索引应在创建表后立即创建。否则就有可能将并非惟一的记录插入表中。如果出现了这种情况,索引创建将因记录重复而失败。







有的时候,表内的某些数据可能并非惟一。这有可能是 “脏” 数据引起的,可能源于多个数据源的整合,也可能源于结果集中返回的列。既然无法使数据惟一,就只能诉诸技术,通过 SQL 消除这些重复行。

从结果集中消除重复行的最简单的方法就是将 DISTINCT 关键字与 SELECT 语句配合使用:

SELECT DISTINCT WORKDEPT FROM EMPLOYEE

对于联结在一起的多个结果集,用户应指定 UNION 而非 UNION ALLUNION ALL 不能消除结果集中的重复行,但是 UNION 能够消除。

SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO > '000100'
  UNION
SELECT WORKDEPT FROM EMPLOYEE WHERE EMPNO < '000900'







表中的惟一性可使用主键、UNIQUE 子句或惟一索引来保证。结果集中的惟一性可使用 select 语句中的 DISTINCT 子句保证,在具有多个结果集的情况下则可使用 UNION 子句。

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