Chinaunix首页 | 论坛 | 博客

Fosdccf.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

sdccf

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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