在此之前曾经写过一篇介绍 “Innodb 索引结构了解 - Innodb Index Structure” 的文章，这次再接着分析一下 MyISAM 存储引擎索引的基本存储结构。

从索引基本的存放数据结构来说，MyISAM 的索引不论是 Primary Key 还是普通 Index，存储结构都基本一样，基本结构都是 Balance Tree （简称为 B-Tree），所有的键值详细信息和行“指针”信息都存放于 B-Tree 的 Leaf Nodes 上面。这个基本的数据结构和 MySQL 的其他存储引擎如 Innodb 也基本相同。但是，MyISAM 的索引并不像 Innodb 存储引擎那样 Primary Key 和 Secondary Index 中存放的数据存在较大区别。在 MyISAM 存储引擎中，Primary Key 和其他的普通 Index 的主要区别仅仅在于 Primary Key 的索引键需要满足是非空的唯一值而已，另外一个区别其实也是每一个普通索引之间都存在的区别，就是整个索引树的键值排列顺序不太一样。

由于 MyISAM 存储引擎中数据行的存储分为固定长度和动态长度两种，所以在 MyISAM 存储引擎的数据文件中定位一行数据所需要信息也存在两种方式。一种是直接通过行号（row number）来定位固定长度表数据的行，另外一种是通过其他一些相对的文件位置标识信息来定位动态长度表数据的行，这里我们姑且将两种方式统称为 RID（Row ID）吧。

下面这张图片展示了 MyISAM 索引的基本存储方式：

原文出自：Sky.Jian 朝阳的天空 MyISAM 索引结构了解 - MyISAM Index Structure

图片服务的特点就是：不修改，少量新增/极少删除，存储量大，需要尽量避免迁移和复制；旧的集群锁定后：对于原来的文件基本上就只删不增了；虽然目前有很多开源的分布式文件系统，但是目前比较便宜的解决方法还是本地硬盘服务器不断一组一组的增加，相互备份的一组服务器作为基础存储，然后前端使用缓存服务器；通过LVS或者CDN进行负载/分布的均衡。

目前一台服务器配上T的存储也相对比较便宜；关键是如何尽量避免使用NFS进行使用；目前我们选择的办法是：图片服务器一组使用2台，一组服务器之间使用NFS相互mount用于备份；另外有上传文件服务器会NFS访问；对外服务文件使用Web服务器负载均衡。而在2台服务器上，会给予基于ID将用户的图片进行存储，存储的分布化会遇到一个问题：固定存储空间随着时间增加再次达到系统的空间/负载的瓶颈。观察了一下Flickr的图片存储地址：好像是在定期启用新的集群，各个时期的域名分布如下：

http://farm1.static.flickr.com 2006年中以前；
http://farm2.static.flickr.com 2006年底；
http://farm3.static.flickr.com 2007年底；
http://farm4.static.flickr.com 2008年底；

user_foo - farm1.static....../20060124_003.jpg
\ farm1.static....../20060324_005.jpg
\ farm1.static....../20060824_021.jpg
\ farm2.static....../20070124_006.jpg
\ farm3.static....../20080124_002.jpg
\ farm4.static....../20081124_001.jpg

另外如果希望前端存储使用的域名一直保持不变，通过目录规则进行rewrite的方式也是可以的，比如：将要发布的内容，后端按时间建立一个域名进行存储；

200711.foo.example.com
200712.foo.example.com
200801.foo.example.com
...
200811.foo.example.com

foo.example.com/200711/ >> 200711.foo.example.com
foo.example.com/200712/ >> 200712.foo.example.com
...
foo.example.com/200811/ >> 200811.foo.example.com

这样就简单的实现了图片存储随时间增加而扩展的，每隔一定时间将上传服务器指向到新的服务器集群；

总的来说，在 MySQL 中的ORDER BY有两种排序实现方式，一种是利用有序索引获取有序数据，另一种则是通过相应的排序算法，将取得的数据在内存中进行排序。

下面将通过实例分析两种排序实现方式及实现图解：
假设有 Table A 和 B 两个表结构分别如下：
sky@localhost : example 01:48:21> show create table A\G
*************************** 1. row ***************************
Table: A
Create Table: CREATE TABLE `A` (
`c1` int(11) NOT NULL default ‘0′,
`c2` char(2) default NULL,
`c3` varchar(16) default NULL,
`c4` datetime default NULL,
PRIMARY KEY  (`c1`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8

sky@localhost : example 01:48:32> show create table B\G
*************************** 1. row ***************************
Table: B
Create Table: CREATE TABLE `B` (
`c1` int(11) NOT NULL default ‘0′,
`c2` char(2) default NULL,
`c3` varchar(16) default NULL,
PRIMARY KEY  (`c1`),
KEY `B_c2_ind` (`c2`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8

1、利用有序索引进行排序，实际上就是当我们 Query 的 ORDER BY 条件和 Query 的执行计划中所利用的 Index 的索引键（或前面几个索引键）完全一致，且索引访问方式为 rang、 ref 或者 index 的时候，MySQL 可以利用索引顺序而直接取得已经排好序的数据。这种方式的 ORDER BY 基本上可以说是最优的排序方式了，因为 MySQL 不需要进行实际的排序操作。

假设我们在Table A 和 B 上执行如下SQL：
sky@localhost : example 01:44:28> EXPLAIN SELECT A.* FROM A,B
-> WHERE A.c1 > 2 AND A.c2 < 5 AND A.c2 = B.c2 ORDER BY A.c1\G
*************************** 1. row ***************************
id: 1
select_type: SIMPLE
table: A
type: range
possible_keys: PRIMARY
key: PRIMARY
key_len: 4
ref: NULL
rows: 3
Extra: Using where
*************************** 2. row ***************************
id: 1
select_type: SIMPLE
table: B
type: ref
possible_keys: B_c2_ind
key: B_c2_ind
key_len: 7
ref: example.A.c2
rows: 2
Extra: Using where; Using index

我们通过执行计划可以看出，MySQL实际上并没有进行实际的排序操作，实际上其整个执行过程如下图所示：

通过相应的排序算法，将取得的数据在内存中进行排序方式，MySQL 比需要将数据在内存中进行排序，所使用的内存区域也就是我们通过 sort_buffer_size 系统变量所设置的排序区。这个排序区是每个 Thread 独享的，所以说可能在同一时刻在 MySQL 中可能存在多个 sort buffer 内存区域。

第二种方式在 MySQL Query Optimizer 所给出的执行计划（通过 EXPLAIN 命令查看）中被称为 filesort。在这种方式中，主要是由于没有可以利用的有序索引取得有序的数据，MySQL只能通过将取得的数据在内存中进行排序然后再将数据返回给 客户端。在 MySQL 中 filesort 的实现算法实际上是有两种的，一种是首先根据相应的条件取出相应的排序字段和可以直接定位行数据的行指针信息，然后在 sort buffer 中进行排序。另外一种是一次性取出满足条件行的所有字段，然后在 sort buffer 中进行排序。

在 MySQL4.1 版本之前只有第一种排序算法，第二种算法是从 MySQL4.1开始的改进算法，主要目的是为了减少第一次算法中需要两次访问表数据的 IO 操作，将两次变成了一次，但相应也会耗用更多的 sort buffer 空间。当然，MySQL4.1开始的以后所有版本同时也支持第一种算法，MySQL 主要通过比较我们所设定的系统参数 max_length_for_sort_data 的大小和 Query 语句所取出的字段类型大小总和来判定需要使用哪一种排序算法。如果 max_length_for_sort_data 更大，则使用第二种优化后的算法，反之使用第一种算法。所以如果希望 ORDER BY 操作的效率尽可能的高，一定要主义 max_length_for_sort_data 参数的设置。曾经就有同事的数据库出现大量的排序等待，造成系统负载很高，而且响应时间变得很长，最后查出正是因为 MySQL 使用了传统的第一种排序算法而导致，在加大了 max_length_for_sort_data 参数值之后，系统负载马上得到了大的缓解，响应也快了很多。

我们再看看 MySQL 需要使用 filesort 实现排序的实例。

假设我们改变一下我们的 Query，换成通过A.c2来排序，再看看情况：
sky@localhost : example 01:54:23> EXPLAIN SELECT A.* FROM A,B
-> WHERE A.c1 > 2 AND A.c2 < 5 AND A.c2 = B.c2 ORDER BY A.c2\G
*************************** 1. row ***************************
id: 1
select_type: SIMPLE
table: A
type: range
possible_keys: PRIMARY
key: PRIMARY
key_len: 4
ref: NULL
rows: 3
Extra: Using where; Using filesort
*************************** 2. row ***************************
id: 1
select_type: SIMPLE
table: B
type: ref
possible_keys: B_c2_ind
key: B_c2_ind
key_len: 7
ref: example.A.c2
rows: 2
Extra: Using where; Using index

MySQL 从 Table A 中取出了符合条件的数据，由于取得的数据并不满足 ORDER BY 条件，所以 MySQL 进行了 filesort 操作，其整个执行过程如下图所示：

在 MySQL 中，filesort 操作还有一个比较奇怪的限制，那就是其数据源必须是来源于一个 Table，所以，如果我们的排序数据如果是两个（或者更多个） Table 通过 Join所得出的，那么 MySQL 必须通过先创建一个临时表（Temporary Table），然后再将此临时表的数据进行排序，如下例所示：

sky@localhost : example 02:46:15> explain select A.* from A,B
-> where A.c1 > 2 and A.c2 < 5 and A.c2 = B.c2 order by B.c3\G

*************************** 1. row ***************************
id: 1
select_type: SIMPLE
table: A
type: range
possible_keys: PRIMARY
key: PRIMARY
key_len: 4
ref: NULL
rows: 3
Extra: Using where; Using temporary; Using filesort
*************************** 2. row ***************************
id: 1
select_type: SIMPLE
table: B
type: ref
possible_keys: B_c2_ind
key: B_c2_ind
key_len: 7
ref: example.A.c2
rows: 2
Extra: Using where

这个执行计划的输出还是有点奇怪的，不知道为什么，MySQL Query Optimizer 将 “Using temporary” 过程显示在第一行对 Table A 的操作中，难道只是为让执行计划的输出少一行？

实际执行过程应该是如下图所示：

Innodb 作为 MySQL 中使用最为广泛的 事务型存储引擎，不仅在事务实现数据版本控制方面和其他存储引擎有一定的区别，其数据结构也是以非常有特点的方式存储的。

每个Innodb表的数据其实可以说就是以一个树型（B-Tree）结构存储的，表的数据和主键（Primary Key）共同组成了一个索引结构，也就是我们常说的Innodb的Clustered Primary Key。在这个Clustered Primary Key中，Leaf Nodes其实就是实际的表记录，我们常规理解上的索引信息全部在Branch Nodes上面。

除了Clustered Primary Key之外的其他所有索引在Innodb中被称为Secondary Index。Secondary Index就和普通的B-Tree索引差不多了，只不过在Secondary Index的所有Leaf Nodes上面同时包含了所指向数据记录的主键信息，而不是直接指向数据记录的位置信息。

所以，在 Innodb 中，如果主键值占用存储空间较大的话，会直接影响整个存储 Innodb 表所需要的物理空间，同时也会直接影响到 Innodb 的查询性能。

下面是画的一张 Innodb 索引基本结构图，包括 Primary Key 和 Secondary Index 两种索引的比较。

原文出自： Innodb 索引结构了解 - Innodb Index Structure

感谢网友Amoeba投递

Aladdin项目是针对企业数据库整合而产生的另外一种数据库切分、读写分离、负载均衡的中间件产品，是amoeba的子产品。沿袭了amoeba其他产品的特性（amoeba for mysql）。

Aladdin产品简介：

目前在amoeba 框架上面已经实现了 amoeba for mysql, amoeba for aladdin

amoeba 中文文档下载地址：

http://amoeba.meidusa.com/amoeba.pdf

amoeba 未来发展方向：

相信很多人都写过下面这种函数，把参数当作hash引用来赋值：

sub foo {
  my $hash = shift;
  $hash->{foo} = 'bar';
}

然后这样调用：

foo($a);

调用之后，$a就变成了一个hash引用，里面包含了 foo => 'bar' 这一对值。 当然你可能会说，干嘛要在foo里面修改参数，直接return $hash不行吗。 当然可以，而且我也推荐使用return的方式， 不过有时候foo函数可能会很复杂，或者由于其他的原因而不得不使用修改参数的方式。

且慢！这种用法有时候会会失败。看下面的例子：

#!/usr/bin/perl

use Data::Dumper;

sub foo {
    my $h = shift;
    $h->{hello} = 'World!';
}

my $a;
my $b = {};
foo($a); print Dumper($a);
foo($b); print Dumper($b);

运行结果：

$VAR1 = undef;
$VAR1 = {
          'hello' => 'World!'
        };

为什么$a执行foo后仍然为undef，而$b就有值？

这是因为，my $a; 没有对$a初始化，此时$a的值为undef。 而调用foo时，参数实际上是传值调用，$a的undef值被赋给了$h变量， 此时$h = undef。而下一行将$h作为hash引用赋值时，系统会自动为$h赋一个空引用作为初始值。 ——但是，这个空引用以及接下来赋给的 hello => 'World!' 的值不会传回给外面的 $a，因为是值传递！

而$b则不同，初始化成一个空hash引用，这样传递给foo的就是个真正的引用值， 这样 hello => 'World!'的赋值可以赋给该引用。

所以，在使用hash引用时，初始化是非常必要的。