Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

  • 博客访问： 104876601
  • 博文数量： 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

  • 博客访问： 104876602
  • 博文数量： 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

  • 博客访问： 104876603
  • 博文数量： 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

  • 博客访问： 104876594
  • 博文数量： 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

  • 博客访问： 104876605
  • 博文数量： 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

  • 博客访问： 104876606
  • 博文数量： 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

  • 博客访问： 104876607
  • 博文数量： 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

  • 博客访问： 104876608
  • 博文数量： 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

  • 博客访问： 104876609
  • 博文数量： 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

  • 博客访问： 104876610
  • 博文数量： 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

  • 博客访问： 104876611
  • 博文数量： 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

  • 博客访问： 104876612
  • 博文数量： 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

  • 博客访问： 104876613
  • 博文数量： 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

  • 博客访问： 104876614
  • 博文数量： 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

  • 博客访问： 104876615
  • 博文数量： 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

  • 博客访问： 104876616
  • 博文数量： 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

  • 博客访问： 104876617
  • 博文数量： 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

  • 博客访问： 104876618
  • 博文数量： 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

  • 博客访问： 104876609
  • 博文数量： 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

  • 博客访问： 104876620
  • 博文数量： 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

  • 博客访问： 104876621
  • 博文数量： 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

  • 博客访问： 104876622
  • 博文数量： 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

  • 博客访问： 104876623
  • 博文数量： 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

  • 博客访问： 104876624
  • 博文数量： 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

  • 博客访问： 104876625
  • 博文数量： 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

  • 博客访问： 104876626
  • 博文数量： 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

  • 博客访问： 104876627
  • 博文数量： 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

  • 博客访问： 104876628
  • 博文数量： 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

  • 博客访问： 104876629
  • 博文数量： 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

  • 博客访问： 104876630
  • 博文数量： 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

  • 博客访问： 104876631
  • 博文数量： 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

  • 博客访问： 104876632
  • 博文数量： 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

  • 博客访问： 104876633
  • 博文数量： 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

  • 博客访问： 104876624
  • 博文数量： 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

  • 博客访问： 104876635
  • 博文数量： 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

  • 博客访问： 104876636
  • 博文数量： 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

  • 博客访问： 104876637
  • 博文数量： 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

  • 博客访问： 104876638
  • 博文数量： 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

  • 博客访问： 104876639
  • 博文数量： 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

  • 博客访问： 104876640
  • 博文数量： 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

  • 博客访问： 104876641
  • 博文数量： 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

  • 博客访问： 104876642
  • 博文数量： 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

  • 博客访问： 104876643
  • 博文数量： 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

  • 博客访问： 104876644
  • 博文数量： 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

  • 博客访问： 104876645
  • 博文数量： 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

  • 博客访问： 104876646
  • 博文数量： 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

  • 博客访问： 104876647
  • 博文数量： 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

  • 博客访问： 104876648
  • 博文数量： 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

  • 博客访问： 104876639
  • 博文数量： 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

  • 博客访问： 104876650
  • 博文数量： 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

  • 博客访问： 104876651
  • 博文数量： 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

  • 博客访问： 104876652
  • 博文数量： 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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(132034) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(132033) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(132032) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(132031) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(132030) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(132029) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(132028) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(132027) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(132026) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(132025) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(132024) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(132023) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(132022) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(132021) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(132020) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(132019) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(132018) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(132017) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(132016) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(132015) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(132014) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(132013) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(132012) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(132011) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(132010) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(132009) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(132008) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(132007) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(132006) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(132005) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(132004) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(132003) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(132002) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(132001) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(132000) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(131999) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(131998) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(131997) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(131996) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(131995) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(131994) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(131993) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(131992) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(131991) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(131990) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(131989) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(131988) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(131987) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(131986) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(131985) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(131984) | 评论(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 允许指定将对表执行的工作负载，然后它将建议要为表创建的索引。

阅读(131983) | 评论(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