Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks

DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)-sdccf-ChinaUnix博客
Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

全部博文（19283）

文章存档

2011年（1）

2009年（125）

2008年（19094）

2007年（63）

我的朋友
最近访客
推荐博文
DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(6)

分类：

2008-05-31 19:11:59

developerWorks



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6



索引

索引 是表的一个或多个列的键值的有序列表。创建索引的原因有两个：

  • 确保一个或多个列中值的惟一性。
  • 提高表查询的性能。DB2 优化器使用索引提高执行查询时的性能，或者以索引的顺序显示查询结果。

索引可以定义为惟一的或非惟一的。非惟一的 索引允许重复的键值；惟一的 索引只允许一个键值在列表中出现一次。惟一的索引允许出现单个空值。然而，第二个空值会导致重复现象，因此不允许。

索引是使用 CREATE INDEX SQL 语句创建的。为支持 PRIMARY KEY 或 UNIQUE 约束，还会隐式地创建索引。当创建惟一索引时，会检查键数据的惟一性，如果发现重复的键数据则该操作失败。

索引可以创建为升序、降序或双向。选择哪个选项取决于应用程序如何访问数据。

在示例中，BOOKID 列上有一个主键。用户常常是搜索书的标题，所以在 BOOKNAME 上建立索引比较合适。下面这个语句在 BOOKNAME 列上创建一个非惟一的升序索引：

CREATE INDEX IBOOKNAME ON BOOKS (BOOKNAME)

索引名 IBOOKNAME 用于创建和删除这个索引。除此之外，在查询或更新表时不使用该名称。

在默认情况下，索引按升序创建，但也可以创建降序索引。甚至可以为索引中的各个列指定不同的顺序。下面的语句在 AUTHORID 和 BOOKNAME 列上定义一个索引。AUTHORID 列的值按降序排序，在同一个 AUTHORID 值中 BOOKNAME 列的值按升序排序：

CREATE INDEX I2BOOKNAME ON BOOKS (AUTHOID DESC, BOOKNAME ASC)

在数据库中创建索引时，按照指定的顺序存储键。索引要求数据处于指定的顺序，从而帮助提高查询的性能。升序索引还用于确定 MIN 列函数的结果；降序索引用于确定 MAX 列函数的结果。如果应用程序还需要数据按与索引相反的顺序排序，那么 DB2 允许创建双向索引。双向 索引使您不必创建逆向索引，而且它使优化器不需要按逆向对数据进行排序。它还允许高效地获得 MIN 和 MAX 函数值。要创建双向索引，应该在 CREATE INDEX 语句中指定 ALLOW REVERSE SCANS 选项：

CREATE INDEX BIBOOKNAME ON BOOKS (BOOKNAME) ALLOW REVERSE SCANS

DB2 不允许创建具有相同定义的多个索引。即使对于为支持主键或惟一性约束而隐式创建的索引，这一点也适用。所以，既然 BOOKS 表已经有了一个在 BOOKID 列上定义的主键，那么尝试在 BOOKID 列上创建索引将失败。

创建一个索引花费的时间比较长。DB2 必须读取每一行来提取键，对这些键进行排序，然后将键值列表写到数据库中。如果表比较大，那么将使用临时表空间对键进行排序。

索引存储在表空间中。如果表驻留在数据库管理的表空间中，就可以选择将索引放在不同的表空间中。在创建表时，使用 INDEXES IN 子句定义这一点。表索引的位置在创建表时设置，除非删除并重新创建表，否则无法改变索引的位置。

DB2 还提供了 DROP INDEX SQL 语句从数据库中删除索引。索引是无法修改的。如果需要更改索引，例如向键中添加另一个列，必须删除并重新创建该索引。







在每个表上，可以将一个索引创建为聚集索引。如果常常以某一次序引用表数据，那么聚集索引比较有用。聚集索引（clustering index） 定义数据在数据库中存储的次序。在插入期间，DB2 会试图将新的行放置得靠近有相似键的行。这样的话，在查询以聚集索引序列请求数据期间，可以更快地检索数据。

要将索引创建为聚集索引，应该在 CREATE INDEX 语句上指定 CLUSTER 子句：

CREATE INDEX IAUTHBKNAME ON BOOKS (AUTHORID,BOOKNAME) CLUSTER

这个语句在 AUTHORID 和 BOOKNAME 列上创建一个索引，并将其作为聚集索引。如果编写的查询要求列出作者及其所写的所有书籍，这个索引会提高查询的性能。


在创建索引时，可以选择包含额外的列数据，这些额外的列数据将与键存储在一起，但实际上它们不是键本身的一部分，所以不被排序。在索引中包含额外列的主要原因是为了提高某些查询的性能：因为索引页面中已经提供了数据值，DB2 就不需要访问数据页面。只能为惟一索引定义包含的列。但是，在强制实施索引的惟一性时不考虑包含的列。

假设我们经常需要获得按 BOOKID 排序的书名列表。查询将如下所示：

SELECT BOOKID,BOOKNAME FROM BOOK ORDER BY BOOKID

下面的语句会创建一个可能提高性能的索引：

CREATE UNIQUE INDEX IBOOKID ON BOOKS (BOOKID) INCLUDE(BOOKNAME)

这样的话，查询结果所需的所有数据都出现在索引中，不需要检索数据页面。

那么，为什么不干脆在索引中包括所有的数据？首先，这需要占用数据库中更多的物理空间，因为本质上表数据与索引中的数据是重复的。其次，每当更新数据值时，数据的所有拷贝都需要更新，在发生许多更新的数据库中，这是一项很大的开销。







下面是创建索引时应该考虑的一些事项：

  • 由于索引是键值的持久性列表，它们要占用数据库空间。所以，创建许多索引就需要数据库中有更多的存储空间。所需的空间量由键列的长度决定。DB2 提供了一个工具帮您估计索引的大小。
  • 索引是值的额外副本，所以当表中的数据被更新时，它们也必须被更新。如果表数据经常被更新，就要考虑额外的索引会对更新性能产生什么样的影响。
  • 如果在适当的列上定义索引，索引会大大提高查询的性能。

DB2 提供了一个称为 Index Advisor 的工具帮助您确定要定义哪些索引。Index Advisor 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

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

上一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(5)

下一篇：DB2 9 基础（730 考试）认证指南，第 5 部分: 处理 DB2 对象(7)

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

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

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

16024965号-6