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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985001
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985002
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985003
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985004
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985005
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985006
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985007
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985008
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104984999
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985010
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985011
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985012
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985013
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985014
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985015
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985016
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985017
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985018
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985019
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985020
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985021
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985022
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985023
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985014
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985025
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985026
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985027
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985028
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985029
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985030
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985031
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985032
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985033
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985034
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985035
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985036
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985037
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985038
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985029
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985040
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985041
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985042
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985043
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985044
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985045
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985046
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985047
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985048
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985049
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985050
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks

DB2 9 基础(730 考试)认证指南,第 5 部分: 处理 DB2 对象(5)-sdccf-ChinaUnix博客
  • 博客访问: 104985051
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 19:11:14

developerWorks



视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118411) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118410) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118409) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118408) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118407) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118406) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118405) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118404) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118403) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118402) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118401) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118400) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118399) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118398) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118397) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118396) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118395) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118394) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118393) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118392) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118391) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118390) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118389) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118388) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118387) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118386) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118385) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118384) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118383) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118382) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118381) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118380) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118379) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118378) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118377) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118376) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118375) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118374) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118373) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118372) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118371) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118370) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118369) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118368) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118367) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118366) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118365) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118364) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118363) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118362) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118361) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


视图

视图 允许不同的用户或应用程序以不同的方式查看相同的数据。这不仅使得数据更容易访问,还可以用它来限制用户可以查看或更新哪些行和列。

例如,假设一个公司有一个包含该公司职员信息的表。经理只需看到他的职员的地址、电话号码和工资信息,而电话簿应用程序需要查看公司中所有职员以及他们的地址和电话号码,但不需查看他们的工资。可以创建一个只显示一个特定部门内职员的所有信息的视图,再创建另一个只显示所有职员的姓名、地址和电话号码的视图。

对于用户来说,视图看起来就像表一样。除视图定义之外,视图在数据库内并不占用空间;视图中显示的数据来自另一个表。可以根据现有的一个表(或多个表)、另一个视图或者表和视图的任意组合创建一个视图。在另一个视图的基础上定义的视图被称为嵌套视图

可以用不同于基表中相应列的列名定义视图。还可以定义一些检查插入或更新的数据是否一直满足视图条件的视图。

数据库中定义的视图的列表存储在系统编目表 SYSIBM.SYSVIEWS 中,SYSIBM.SYSVIEWS 还有一个根据它定义的名为 SYSCAT.VIEWS 的视图。系统编目还有一个 SYSCAT.VIEWDEP,对于数据库中定义的每一个视图所依赖的每个视图或表,SYSCAT.VIEWDEP 中都有一行。另外,每个视图都在 SYSIBM.SYSTABLES 中有一个条目,在 SYSIBM.SYSCOLUMNS 中有多个条目,因为可以像表一样使用视图。

CREATE VIEW SQL 语句用于定义视图。SELECT 语句用于指定将在视图中显示哪些行与列。

例如,假设想创建一个只显示 BOOKS 表中非小说类书籍的视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'

定义这个视图后,SYSCAT.VIEWS、SYSCAT.VIEWDEP 和 SYSCAT.TABLES 中将有对应的条目。

要在视图中定义不同于基表中那些列的列名,可以在 CREATE VIEW 语句中指定它们。以下语句创建一个 MYBOOKVIEW 视图,该视图包含两列:TITLE(代表 BOOKNAME 列)和 TYPE(代表 BOOKTYPE 列)。

CREATE VIEW MYBOOKVIEW (TITLE,TYPE) AS 
       SELECT BOOKNAME,BOOKTYPE FROM BOOKS 

DROP VIEW SQL 语句用于从数据库中删除视图。如果删除一个视图所基于的表或另一个视图,那么这个视图依然在数据库中被定义,但变得不起作用。SYSCAT.VIEWS 的 VALID 列表明视图是有效的(‘Y’)还是无效的(‘X’)。即使重新创建基表,无效的视图仍然是无效的;必须也重新创建它。

可以从数据库中删除 NONFICTIONBOOKS 视图:

DROP VIEW NONFICTIONBOOKS
          

不能修改视图;要更改视图定义,必须删除视图,然后重新创建它。DB2 提供的 ALTER VIEW 语句只用于修改引用类型。







在创建一个视图时,可以将它定义为只读视图 或者可更新视图。视图的 SELECT 语句决定视图是只读的还是可更新的。一般情况下,如果视图中的行可以映射到基表中的行,那么该视图就是可更新的。例如,就像前面示例中定义的那样,视图 NONFICTIONBOOKS 是可更新的,因为视图中的每一行都是基表中的行。

创建可更新视图的规则很复杂,它们取决于查询的定义。例如,使用 VALUESDISTINCTJOIN 特性的视图是不可更新的。通过查看 SYSCAT.VIEWS 的 READONLY 列很容易就能确定视图是不是可更新的:Y 表示只读,N 表示非只读。

DB2 SQL Reference 中说明了创建可更新视图的详细规则(请参阅 参考资料)。

先前定义的 NONFICTIONBOOKS 视图只包含 BOOKTYPE 为 N 的行。如果向这个视图中插入一个 BOOKTYPE 为 F 的行,DB2 将把该行插入到基表 BOOKS 中。但是,如果以后从视图中进行选择,通过该视图却看不到新插入的行。如果不想允许用户插入视图范围以外的行,那么在定义视图时可以使用检查选项。使用 WITH CHECK OPTION 定义视图会让 DB2 检查使用视图的语句是否满足视图的条件。

下面的语句用 WITH CHECK OPTION 定义一个视图:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
       WITH CHECK OPTION

这个视图仍然限制用户只能看到非小说类的书;另外,它还防止用户插入 BOOKTYPE 列的值不为 N 的行,并防止把现有行中 BOOKTYPE 列的值更新为 N 以外的值。例如,下列语句将不再允许使用:

INSERT INTO NONFICTIONBOOKS VALUES (...,'F'); 
UPDATE NONFICTIONBOOKS SET BOOKTYPE = 'F' WHERE BOOKID = 111







在定义嵌套视图时,检查选项可以用于限制操作。但是,还可以指定其他子句来定义如何继承限制。检查选项可以定义为 CASCADEDLOCAL。如果没有指定关键字,CASCADED 是默认值。为说明 CASCADEDLOCAL 行为的不同,我们来看几个可能的场景。

当用 WITH CASCADED CHECK OPTION 创建视图时,所有针对该视图执行的语句都必须满足视图和所有底层视图的条件 —— 即使那些视图不是带检查选项定义的,也是如此。假设在创建 NONFICTIONBOOKS 时没有带检查选项,也可以使用 CASCADED 关键字在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS1:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS1 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH CASCADED CHECK OPTION

将不允许下列 INSERT 语句,因为它们不满足其中至少一个视图的条件:

INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'N')
INSERT INTO NONFICTIONBOOKS1 VALUES(120,..,'F')
INSERT INTO NONFICTIONBOOKS1 VALUES( 10,..,'F')

但是, 允许下面的 INSERT 语句,因为这两个视图的条件它都满足:

INSERT INTO NONFICTIONBOOKS1 VALUES(120,...,'N')

接下来,假设用 WITH LOCAL CHECK OPTION 在视图 NONFICTIONBOOKS 的基础上创建视图 NONFICTIONBOOKS2。现在,针对这个视图执行的语句只需要满足指定了检查选项的视图的条件:

CREATE VIEW NONFICTIONBOOKS AS 
       SELECT * FROM BOOKS WHERE BOOKTYPE = 'N'
CREATE VIEW NONFICTIONBOOKS2 AS 
       SELECT * FROM NONFICTIONBOOKS WHERE BOOKID > 100
       WITH LOCAL CHECK OPTION

在这种情况下,将不允许下面的 INSERT 语句,因为它们不满足 NONFICTIONBOOKS2 视图的 BOOKID > 100 这个条件:

INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(10,..,'F')

但是,尽管值 N 不满足 NONFICTIONBOOKS 视图的 BOOKTYPE = 'N' 这个条件,也会允许下面的 INSERT 语句:

INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'N')
INSERT INTO NONFICTIONBOOKS2 VALUES(120,..,'F')
阅读(118360) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~