<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>Terrysco&#039;s Blog &#187; mysql</title>
	<atom:link href="http://www.terrysco.com/node/tag/mysql/feed" rel="self" type="application/rss+xml" />
	<link>http://www.terrysco.com</link>
	<description>仅关注于互联网行业， Linux平台开发。</description>
	<lastBuildDate>Sat, 05 Nov 2011 21:24:06 +0000</lastBuildDate>
	<language>en</language>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
	<generator>http://wordpress.org/?v=3.2.1</generator>
		<item>
		<title>Mysql的一些问题总结</title>
		<link>http://www.terrysco.com/node/mysql-tips.html</link>
		<comments>http://www.terrysco.com/node/mysql-tips.html#comments</comments>
		<pubDate>Mon, 28 Sep 2009 15:23:25 +0000</pubDate>
		<dc:creator>terrysco</dc:creator>
				<category><![CDATA[Linux/Mac/DB]]></category>
		<category><![CDATA[mysql]]></category>

		<guid isPermaLink="false">http://www.terrysco.com/?p=269</guid>
		<description><![CDATA[最近时间比较多，决定花些时间深入研究下mysql，尤其是性能和高负载站点的优化问题。不可避免的再次察漏补缺下基础知识，还是发现一些以前忽略的小细节，正可谓温故知新。 使用alter语句修改表的时候，change和modify都可以修改表的定义，不同的是change后面需要写两次列名，但可以修改列名，而modify则不行。 insert语句一个很好的特性：可以一次插入多条记录。格式为：insert into table (field 1, &#8230; , fieldn) values (value1, &#8230; , valuen), (value1, &#8230; , valuen); 这个特性在插入大量记录时，节省很多网络开销，大大提高效率。 其实查询Mysql安装后自带的帮助文档是很方便的，在提示符中键入 ? contents，根据结果依次使用问号操作符做进一步查询，即可获得详细信息。 Blob和text类型会引起一些性能问题，尤其是删除了大量记录的时候。应该使用optimize table功能进行碎片整理。 MyISAM引擎建议使用固定长度的数据列代替可变长度的数据列，而innodb引擎建议使用varchar类型，因为char平均占用空间多于varchar。 可以使用合成索引来提高大文本字段的查询性能，在表的设计中多一个字段，用来存储大文本的md5值，精确匹配大文本查询的时候可以利用该文本的md5值进行查询，以减少I/O，提高查询效率。]]></description>
			<content:encoded><![CDATA[<p>最近时间比较多，决定花些时间深入研究下mysql，尤其是性能和高负载站点的优化问题。不可避免的再次察漏补缺下基础知识，还是发现一些以前忽略的小细节，正可谓温故知新。</p>
<ol>
<li>使用alter语句修改表的时候，change和modify都可以修改表的定义，不同的是change后面需要写两次列名，但可以修改列名，而modify则不行。</li>
<li>insert语句一个很好的特性：可以一次插入多条记录。格式为：insert into table (field 1, &#8230; , fieldn) values (value1, &#8230; , valuen), (value1, &#8230; , valuen); 这个特性在插入大量记录时，节省很多网络开销，大大提高效率。</li>
<li>其实查询Mysql安装后自带的帮助文档是很方便的，在提示符中键入 ? contents，根据结果依次使用问号操作符做进一步查询，即可获得详细信息。</li>
<li>Blob和text类型会引起一些性能问题，尤其是删除了大量记录的时候。应该使用optimize table功能进行碎片整理。</li>
<li>MyISAM引擎建议使用固定长度的数据列代替可变长度的数据列，而innodb引擎建议使用varchar类型，因为char平均占用空间多于varchar。</li>
<li>可以使用合成索引来提高大文本字段的查询性能，在表的设计中多一个字段，用来存储大文本的md5值，精确匹配大文本查询的时候可以利用该文本的md5值进行查询，以减少I/O，提高查询效率。</li>
</ol>
]]></content:encoded>
			<wfw:commentRss>http://www.terrysco.com/node/mysql-tips.html/feed</wfw:commentRss>
		<slash:comments>1</slash:comments>
		</item>
		<item>
		<title>[转]深入Mysql字符集设置</title>
		<link>http://www.terrysco.com/node/mysql-charset.html</link>
		<comments>http://www.terrysco.com/node/mysql-charset.html#comments</comments>
		<pubDate>Sat, 15 Nov 2008 04:24:38 +0000</pubDate>
		<dc:creator>terrysco</dc:creator>
				<category><![CDATA[Linux/Mac/DB]]></category>
		<category><![CDATA[mysql]]></category>

		<guid isPermaLink="false">http://www.terrysco.com/?p=250</guid>
		<description><![CDATA[作者:laruence(http://www.laruence.com/) · 本文地址: http://www.laruence.com/2008/01/05/12.html · 转载请注明出处 根据Chaos  Wang的PPT整理而成， 在此再次感谢Chaos Wang的此次TechTalk 基本概念 • 字符(Character)是指人类语言中最小的表义符号。例如’A&#8217;、’B&#8217;等； • 给定一系列字符，对每个字符赋予一个数值，用数值来代表对应的字符，这一数值就是字符的编码(Encoding)。例如，我们给字符’A&#8217;赋予数值0，给字符’B&#8217;赋予数值1，则0就是字符’A&#8217;的编码； • 给定一系列字符并赋予对应的编码后，所有这些字符和编码对组成的集合就是字符集(Character Set)。例如，给定字符列表为{’A&#8217;,’B&#8217;}时，{’A&#8217;=&#62;0, ‘B’=&#62;1}就是一个字符集； • 字符序(Collation)是指在同一字符集内字符之间的比较规则； • 确定字符序后，才能在一个字符集上定义什么是等价的字符，以及字符之间的大小关系； • 每个字符序唯一对应一种字符集，但一个字符集可以对应多种字符序，其中有一个是默认字符序(Default Collation)； • MySQL中的字符序名称遵从命名惯例：以字符序对应的字符集名称开头；以_ci(表示大小写不敏感)、_cs(表示大小写敏感)或_bin(表示按编码值比较)结尾。例如：在字符序“utf8_general_ci”下，字符“a”和“A”是等价的； MySQL字符集设置 • 系统变量： – character_set_server：默认的内部操作字符集 – character_set_client：客户端来源数据使用的字符集 – character_set_connection：连接层字符集 – character_set_results：查询结果字符集 – character_set_database：当前选中数据库的默认字符集 – character_set_system：系统元数据(字段名等)字符集 – 还有以collation_开头的同上面对应的变量，用来描述字符序。 • 用introducer指定文本字符串的字符集： – 格式为：[_charset] ’string’ [COLLATE collation] – 例如： • [...]]]></description>
			<content:encoded><![CDATA[<p>作者:laruence(<a title="风雪之隅" href="http://www.laruence.com/"><span style="text-decoration: underline;"><span style="color: #0000cc;">http://www.laruence.com/)</span></span></a><br />
· 本文地址: <a title="深入Mysql字符集设置" href="http://www.laruence.com/2008/01/05/12.html"><span style="text-decoration: underline;"><span style="color: #0000cc;">http://www.laruence.com/2008/01/05/12.html</span></span></a><br />
· 转载请注明出处</p>
<div id="msgcns!BDC1482E8FA76F7D!290">
<p><span style="color: #21c0a9;"><br />
根据Chaos  Wang的PPT整理而成， 在此再次感谢Chaos Wang的此次TechTalk</span></p>
<h4><strong>基本概念</strong></h4>
<p>• 字符(Character)是指人类语言中最小的表义符号。例如’A&#8217;、’B&#8217;等；</p>
<p>• 给定一系列字符，对每个字符赋予一个数值，用数值来代表对应的字符，这一数值就是字符的编码(Encoding)。例如，我们给字符’A&#8217;赋予数值0，给字符’B&#8217;赋予数值1，则0就是字符’A&#8217;的编码；</p>
<p>• 给定一系列字符并赋予对应的编码后，所有这些字符和编码对组成的集合就是字符集(Character Set)。例如，给定字符列表为{’A&#8217;,’B&#8217;}时，{’A&#8217;=&gt;0, ‘B’=&gt;1}就是一个字符集；</p>
<p>• 字符序(Collation)是指在同一字符集内字符之间的比较规则；</p>
<p>• 确定字符序后，才能在一个字符集上定义什么是等价的字符，以及字符之间的大小关系；</p>
<p>• 每个字符序唯一对应一种字符集，但一个字符集可以对应多种字符序，其中有一个是默认字符序(Default Collation)；</p>
<p>• MySQL中的字符序名称遵从命名惯例：以字符序对应的字符集名称开头；以_ci(表示大小写不敏感)、_cs(表示大小写敏感)或_bin(表示按编码值比较)结尾。例如：在字符序“utf8_general_ci”下，字符“a”和“A”是等价的；</p>
<h4><strong>MySQL字符集设置</strong></h4>
<p>• 系统变量：</p>
<p>– <strong>character_set_server</strong>：默认的内部操作字符集</p>
<p>– <strong>character_set_client</strong>：客户端来源数据使用的字符集</p>
<p>– <strong>character_set_connection</strong>：连接层字符集</p>
<p>– <strong>character_set_results</strong>：查询结果字符集</p>
<p>– <strong>character_set_database</strong>：当前选中数据库的默认字符集</p>
<p>– <strong>character_set_system</strong>：系统元数据(字段名等)字符集</p>
<p>– 还有以<strong>collation_</strong>开头的同上面对应的变量，用来描述字符序。</p>
<p>• 用introducer指定文本字符串的字符集：</p>
<p>– 格式为：[_charset] ’string’ [COLLATE collation]</p>
<p>– 例如：</p>
<p>• SELECT _latin1 ’string’;</p>
<p>• SELECT _utf8 ‘你好’ COLLATE utf8_general_ci;</p>
<p>– 由introducer修饰的文本字符串在请求过程中不经过多余的转码，直接转换为内部字符集处理。</p>
<h4><strong>MySQL中的字符集转换过程</strong></h4>
<p>1. MySQL Server收到请求时将请求数据从character_set_client转换为character_set_connection；</p>
<p>2. 进行内部操作前将请求数据从character_set_connection转换为内部操作字符集，其确定方法如下：</p>
<p>• 使用每个数据字段的CHARACTER SET设定值；</p>
<p>• 若上述值不存在，则使用对应数据表的DEFAULT CHARACTER SET设定值(MySQL扩展，非SQL标准)；</p>
<p>• 若上述值不存在，则使用对应数据库的DEFAULT CHARACTER SET设定值；</p>
<p>• 若上述值不存在，则使用character_set_server设定值。</p>
<p>3. 将操作结果从内部操作字符集转换为character_set_results。</p>
<p><a href="http://by1.storage.msn.com/y1pe_jYelFdqS5ZJBldNnN9gSgYvu_yPc2SPiYr0F0bF7hv5mC9eAa4eB1O_GcmQX4LuVf7yiUB9a4WppnLOMJURShP4yYRLXXr?PARTNER=WRITER"><img style="border-width: 0px;" src="http://by1.storage.msn.com/y1pe_jYelFdqS4M9uVHASUOPMiWGlORakiVALpmSBiPqEK3tIk0pus8_MDYpf2ILdCT9o1jW0SU9cv5aDsszqDz1rmEP6crey3P?PARTNER=WRITER" border="0" alt="图片1" width="426" height="373" /></a></p>
<h4><strong>常见问题解析</strong></h4>
<p>• 向默认字符集为utf8的数据表插入utf8编码的数据前没有设置连接字符集，查询时设置连接字符集为utf8</p>
<p>– 插入时根据MySQL服务器的默认设置，character_set_client、character_set_connection和character_set_results均为latin1；</p>
<p>– 插入操作的数据将经过latin1=&gt;latin1=&gt;utf8的字符集转换过程，这一过程中每个插入的汉字都会从原始的3个字节变成6个字节保存；</p>
<p>– 查询时的结果将经过utf8=&gt;utf8的字符集转换过程，将保存的6个字节原封不动返回，产生乱码……</p>
<p><a href="http://ixxpjg.bay.livefilestore.com/y1pU6_cSvL4HBsiKr55ChShxx15zfX64SQiUj_czboWqPod1v6K0Wb-LebCyQC1tSi7E9AH1qnY8ACb8E9STxpB268dg3ZYaHFy?PARTNER=WRITER"><img style="border-width: 0px; width: 664px; height: 210px;" src="http://by1.storage.msn.com/y1pe_jYelFdqS65OW_dplyOcCLGOp_5HSQ2yXdkDqtt3VNeuqllpNEkzOzQsKv2mpa71xcdFHmJjZ4Nte_6LGpf7zhgoeoIUoO8?PARTNER=WRITER" border="0" alt="图片2" width="553" height="236" /></a></p>
<p>• 向默认字符集为latin1的数据表插入utf8编码的数据前设置了连接字符集为utf8</p>
<p>– 插入时根据连接字符集设置，character_set_client、character_set_connection和character_set_results均为utf8；</p>
<p>– 插入数据将经过utf8=&gt;utf8=&gt;latin1的字符集转换，若原始数据中含有\u0000~\u00ff范围以外的Unicode字 符，会因为无法在latin1字符集中表示而被转换为“?”(0×3F)符号，以后查询时不管连接字符集设置如何都无法恢复其内容了。</p>
<p><a href="http://ixxpjg.bay.livefilestore.com/y1pU6_cSvL4HBsnogZw0HevAR0xadYeRuYNzavtKLG29pZqXskdoxoXjOVZ3rZcYUyu74ISQqNaW2kPQ5ZKj6cc2cIudvq5Y2hF?PARTNER=WRITER"><img style="border-width: 0px; width: 659px; height: 246px;" src="http://by1.storage.msn.com/y1pe_jYelFdqS4EkLLX7fHY9BjVxN1dxUWGpFTyfv_Lk8CdCifQ1ZXIPOGfhFV2emYq46cOYM004D1ft_-dDLfvgEicuIhhGFRB?PARTNER=WRITER" border="0" alt="图片3" width="559" height="246" /></a></p>
<h4><strong>检测字符集问题的一些手段</strong></h4>
<p>• SHOW CHARACTER SET;</p>
<p>• SHOW COLLATION;</p>
<p>• SHOW VARIABLES LIKE ‘character%’;</p>
<p>• SHOW VARIABLES LIKE ‘collation%’;</p>
<p>• SQL函数HEX、LENGTH、CHAR_LENGTH</p>
<p>• SQL函数CHARSET、COLLATION</p>
<h4>使用MySQL字符集时的建议</h4>
<p>• 建立数据库/表和进行数据库操作时尽量显式指出使用的字符集，而不是依赖于MySQL的默认设置，否则MySQL升级时可能带来很大困扰；</p>
<p>• 数据库和连接字符集都使用latin1时虽然大部分情况下都可以解决乱码问题，但缺点是无法以字符为单位来进行SQL操作，一般情况下将数据库和连接字符集都置为utf8是较好的选择；</p>
<p>• 使用mysql C API时，初始化数据库句柄后马上用mysql_options设定MYSQL_SET_CHARSET_NAME属性为utf8，这样就不用显式地用 SET NAMES语句指定连接字符集，且用mysql_ping重连断开的长连接时也会把连接字符集重置为utf8；</p>
<p>• 对于mysql PHP API，一般页面级的PHP程序总运行时间较短，在连接到数据库以后显式用SET NAMES语句设置一次连接字符集即可；但当使用长连接时，请注意保持连接通畅并在断开重连后用SET NAMES语句显式重置连接字符集。</p>
<h4>其他注意事项</h4>
<p>• my.cnf中的default_character_set设置只影响mysql命令连接服务器时的连接字符集，不会对使用libmysqlclient库的应用程序产生任何作用！</p>
<p>• 对字段进行的SQL函数操作通常都是以内部操作字符集进行的，不受连接字符集设置的影响。</p>
<p>• SQL语句中的裸字符串会受到连接字符集或introducer设置的影响，对于比较之类的操作可能产生完全不同的结果，需要小心！</p></div>
]]></content:encoded>
			<wfw:commentRss>http://www.terrysco.com/node/mysql-charset.html/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>[转]MySQL索引分析和优化</title>
		<link>http://www.terrysco.com/node/mysql-index-opt.html</link>
		<comments>http://www.terrysco.com/node/mysql-index-opt.html#comments</comments>
		<pubDate>Tue, 15 Jul 2008 02:56:49 +0000</pubDate>
		<dc:creator>terrysco</dc:creator>
				<category><![CDATA[Linux/Mac/DB]]></category>
		<category><![CDATA[mysql]]></category>

		<guid isPermaLink="false">http://www.terrysco.com/?p=245</guid>
		<description><![CDATA[// 300) { text = text + "\r\n\n本文来自CSDN博客，转载请标明出处：" + location.href; clipboardData.setData("text", text); } }, 100); } } // ]]&#62; // 索引用来快速地寻找那些具有特定值的记录，所有MySQL索引都以B-树的形式保存。如果没有索引，执行查询时MySQL必须从第一个记录开始扫描 整个表的所有记录，直至找到符合要求的记录。表里面的记录数量越多，这个操作的代价就越高。如果作为搜索条件的列上已经创建了索引，MySQL无需扫描任 何记录即可迅速得到目标记录所在的位置。如果表有1000个记录，通过索引查找记录至少要比顺序扫描记录快100倍。 假设我们创建了一个名为people的表： CREATE TABLE people ( peopleid SMALLINT NOT NULL, name CHAR(50) NOT NULL ); 然后，我们完全随机把1000个不同name值插入到people表。下图显示了people表所在数据文件的一小部分： 可以看到，在数据文件中name列没有任何明确的次序。如果我们创建了name列的索引，MySQL将在索引中排序name列： 对于索引中的每一项，MySQL在内部为它保存一个数据文件中实际记录所在位置的“指针”。因此，如果我们要查找name等于 “Mike”记录的peopleid（SQL命令为“SELECT peopleid FROM people WHERE name=&#8217;Mike&#8217;;”），MySQL能够在name的索引中查找“Mike”值，然后直接转到数据文件中相应的行，准确地返回该行的 peopleid（999）。在这个过程中，MySQL只需处理一个行就可以返回结果。如果没有“name”列的索引，MySQL要扫描数据文件中的所有 记录，即1000个记录！显然，需要MySQL处理的记录数量越少，则它完成任务的速度就越快。 索引的类型 MySQL提供多种索引类型供选择： 普通索引 这是最基本的索引类型，而且它没有唯一性之类的限制。普通索引可以通过以下几种方式创建： 创建索引，例如CREATE INDEX &#60;索引的名字&#62; [...]]]></description>
			<content:encoded><![CDATA[<h1><cite> </cite></h1>
<div><script type="text/javascript">// <![CDATA[
						document.body.oncopy = function() {
							if (window.clipboardData) {
								setTimeout(function() {
									var text = clipboardData.getData("text"); 
									if (text &#038;&#038; text.length>300) {
										text = text + "\r\n\n本文来自CSDN博客，转载请标明出处：" + location.href;
										clipboardData.setData("text", text); 
									}
								}, 100);
							}
						}
// ]]&gt;</script> <script type="text/javascript">// <![CDATA[
function StorePage(){d=document;t=d.selection?(d.selection.type!='None'?d.selection.createRange().text:''):(d.getSelection?d.getSelection():'');void(keyit=window.open('http://www.365key.com/storeit.aspx?t='+escape(d.title)+'&#038;u='+escape(d.location.href)+'&#038;c='+escape(t),'keyit','scrollbars=no,width=475,height=575,left=75,top=20,status=no,resizable=yes'));keyit.focus();}
// ]]&gt;</script>索引用来快速地寻找那些具有特定值的记录，所有MySQL索引都以B-树的形式保存。如果没有索引，执行查询时MySQL必须从第一个记录开始扫描 整个表的所有记录，直至找到符合要求的记录。表里面的记录数量越多，这个操作的代价就越高。如果作为搜索条件的列上已经创建了索引，MySQL无需扫描任 何记录即可迅速得到目标记录所在的位置。如果表有1000个记录，通过索引查找记录至少要比顺序扫描记录快100倍。</p>
<p>假设我们创建了一个名为people的表：</p>
<table border="1" cellspacing="0" cellpadding="2" width="550" align="center">
<tbody>
<tr>
<td bgcolor="#e6e6e6">
<pre>CREATE TABLE people ( peopleid SMALLINT NOT NULL, name CHAR(50) NOT NULL );</pre>
</td>
</tr>
</tbody>
</table>
<p>然后，我们完全随机把1000个不同name值插入到people表。下图显示了people表所在数据文件的一小部分：</p>
<p><img src="http://www.phpe.net/uploads/images/article_1043248393.gif" alt="" hspace="0" width="232" height="115" /></p>
<p>可以看到，在数据文件中name列没有任何明确的次序。如果我们创建了name列的索引，MySQL将在索引中排序name列：</p>
<p><img src="http://www.phpe.net/uploads/images/article_1043248412.gif" alt="" hspace="0" width="162" height="119" /></p>
<p>对于索引中的每一项，MySQL在内部为它保存一个数据文件中实际记录所在位置的“指针”。因此，如果我们要查找name等于 “Mike”记录的peopleid（SQL命令为“SELECT peopleid FROM people WHERE name=&#8217;Mike&#8217;;”），MySQL能够在name的索引中查找“Mike”值，然后直接转到数据文件中相应的行，准确地返回该行的 peopleid（999）。在这个过程中，MySQL只需处理一个行就可以返回结果。如果没有“name”列的索引，MySQL要扫描数据文件中的所有 记录，即1000个记录！显然，需要MySQL处理的记录数量越少，则它完成任务的速度就越快。</p>
<p><span style="color: #000099;"><strong style="font-size: 14pt;">索引的类型</strong></span></p>
<p>MySQL提供多种索引类型供选择：</p>
<p><strong>普通索引</strong></p>
<p>这是最基本的索引类型，而且它没有唯一性之类的限制。普通索引可以通过以下几种方式创建：</p>
<table border="1" cellspacing="0" cellpadding="2" width="550" align="center">
<tbody>
<tr>
<td bgcolor="#e6e6e6">
<pre>创建索引，例如CREATE INDEX &lt;索引的名字&gt; ON tablename (列的列表);
修改表，例如ALTER TABLE tablename ADD INDEX [索引的名字] (列的列表);
创建表的时候指定索引，例如CREATE TABLE tablename ( [...], INDEX [索引的名字] (列的列表) );</pre>
</td>
</tr>
</tbody>
</table>
<p><strong>唯一性索引</strong></p>
<p>这种索引和前面的“普通索引”基本相同，但有一个区别：索引列的所有值都只能出现一次，即必须唯一。唯一性索引可以用以下几种方式创建：</p>
<table border="1" cellspacing="0" cellpadding="2" width="550" align="center">
<tbody>
<tr>
<td bgcolor="#e6e6e6">
<pre>创建索引，例如CREATE UNIQUE INDEX &lt;索引的名字&gt; ON tablename (列的列表);
修改表，例如ALTER TABLE tablename ADD UNIQUE [索引的名字] (列的列表);
创建表的时候指定索引，例如CREATE TABLE tablename ( [...], UNIQUE [索引的名字] (列的列表)
);</pre>
</td>
</tr>
</tbody>
</table>
<p><strong>主键</strong></p>
<p>主键是一种唯一性索引，但它必须指定为“PRIMARY KEY”。如果你曾经用过AUTO_INCREMENT类型的列，你可能已经熟悉主键之类的概念了。主键一般在创建表的时候指定，例如“CREATE TABLE tablename ( [...], PRIMARY KEY (列的列表) ); ”。但是，我们也可以通过修改表的方式加入主键，例如“ALTER TABLE tablename ADD PRIMARY KEY (列的列表); ”。每个表只能有一个主键。</p>
<p><strong>全文索引</strong></p>
<p>MySQL从3.23.23版开始支持全文索引和全文检索。在 MySQL中，全文索引的索引类型为FULLTEXT。全文索引可以在VARCHAR或者TEXT类型的列上创建。它可以通过CREATE TABLE命令创建，也可以通过ALTER TABLE或CREATE INDEX命令创建。对于大规模的数据集，通过ALTER TABLE（或者CREATE INDEX）命令创建全文索引要比把记录插入带有全文索引的空表更快。本文下面的讨论不再涉及全文索引，要了解更多信息，请参见MySQL documentation。</p>
<p><span style="color: #000099;"><strong style="font-size: 14pt;">单列索引与多列索引</strong></span></p>
<p>索引可以是单列索引，也可以是多列索引。下面我们通过具体的例子来说明这两种索引的区别。假设有这样一个people表：</p>
<table border="1" cellspacing="0" cellpadding="2" width="550" align="center">
<tbody>
<tr>
<td bgcolor="#e6e6e6">
<pre>CREATE TABLE people ( peopleid SMALLINT NOT NULL AUTO_INCREMENT, firstname CHAR(50)
NOT NULL, lastname CHAR(50) NOT NULL, age SMALLINT NOT NULL, townid SMALLINT NOT
NULL, PRIMARY KEY (peopleid) );</pre>
</td>
</tr>
</tbody>
</table>
<p>下面是我们插入到这个people表的数据：</p>
<p><img src="http://www.phpe.net/uploads/images/article_1043248425.gif" alt="" hspace="0" width="446" height="149" /></p>
<p>这个数据片段中有四个名字为“Mikes”的人（其中两个姓Sullivans，两个姓McConnells），有两个年龄为17岁的人，还有一个名字与众不同的Joe Smith。</p>
<p>这 个表的主要用途是根据指定的用户姓、名以及年龄返回相应的peopleid。例如，我们可能需要查找姓名为Mike Sullivan、年龄17岁用户的peopleid（SQL命令为SELECT peopleid FROM people WHERE firstname=&#8217;Mike&#8217; AND lastname=&#8217;Sullivan&#8217; AND age=17;）。由于我们不想让MySQL每次执行查询就去扫描整个表，这里需要考虑运用索引。</p>
<p>首先，我们可以考虑在单个列上创建 索引，比如firstname、lastname或者age列。如果我们创建firstname列的索引（ALTER TABLE people ADD INDEX firstname (firstname);），MySQL将通过这个索引迅速把搜索范围限制到那些firstname=&#8217;Mike&#8217;的记录，然后再在这个“中间结果集”上 进行其他条件的搜索：它首先排除那些lastname不等于“Sullivan”的记录，然后排除那些age不等于17的记录。当记录满足所有搜索条件之 后，MySQL就返回最终的搜索结果。</p>
<p>由于建立了firstname列的索引，与执行表的完全扫描相比，MySQL的效率提高了很 多，但我们要求MySQL扫描的记录数量仍旧远远超过了实际所需要的。虽然我们可以删除firstname列上的索引，再创建lastname或者age 列的索引，但总地看来，不论在哪个列上创建索引搜索效率仍旧相似。</p>
<p>为了提高搜索效率，我们需要考虑运用多列索引。如果为firstname、lastname和age这三个列创建一个多列索引，MySQL只需一次检索就能够找出正确的结果！下面是创建这个多列索引的SQL命令：</p>
<table border="1" cellspacing="0" cellpadding="2" width="550" align="center">
<tbody>
<tr>
<td bgcolor="#e6e6e6">
<pre>ALTER TABLE people ADD INDEX fname_lname_age (firstname,lastname,age);</pre>
</td>
</tr>
</tbody>
</table>
<p>由于索引文件以B-树格式保存，MySQL能够立即转到合适的firstname，然后再转到合适的lastname，最后转到合适的age。在没有扫描数据文件任何一个记录的情况下，MySQL就正确地找出了搜索的目标记录！</p>
<p>那 么，如果在firstname、lastname、age这三个列上分别创建单列索引，效果是否和创建一个firstname、lastname、age 的多列索引一样呢？答案是否定的，两者完全不同。当我们执行查询的时候，MySQL只能使用一个索引。如果你有三个单列的索引，MySQL会试图选择一个 限制最严格的索引。但是，即使是限制最严格的单列索引，它的限制能力也肯定远远低于firstname、lastname、age这三个列上的多列索引。</p>
<p><span style="color: #000099;"><strong style="font-size: 14pt;">最左前缀</strong></span></p>
<p>多列索引还有另外一个优点，它通过称为最左前缀（Leftmost Prefixing）的概念体现出来。继续考虑前面的例子，现在我们有一个firstname、lastname、age列上的多列索引，我们称这个索引 为fname_lname_age。当搜索条件是以下各种列的组合时，MySQL将使用fname_lname_age索引：</p>
<table border="1" cellspacing="0" cellpadding="2" width="550" align="center">
<tbody>
<tr>
<td bgcolor="#e6e6e6">
<pre>firstname，lastname，age
firstname，lastname
firstname</pre>
</td>
</tr>
</tbody>
</table>
<p>从另一方面理解，它相当于我们创建了(firstname，lastname，age)、(firstname，lastname)以及(firstname)这些列组合上的索引。下面这些查询都能够使用这个fname_lname_age索引：</p>
<table border="1" cellspacing="0" cellpadding="2" width="550" align="center">
<tbody>
<tr>
<td bgcolor="#e6e6e6">
<pre>SELECT peopleid FROM people WHERE firstname='Mike' AND lastname='Sullivan' AND
age='17'; SELECT peopleid FROM people WHERE firstname='Mike' AND
lastname='Sullivan'; SELECT peopleid FROM people WHERE firstname='Mike'; The
following queries cannot use the index at all: SELECT peopleid FROM people WHERE
lastname='Sullivan'; SELECT peopleid FROM people WHERE age='17'; SELECT peopleid
FROM people WHERE lastname='Sullivan' AND age='17';</pre>
</td>
</tr>
</tbody>
</table>
<p><span style="color: #000099;"><strong style="font-size: 14pt;">选择索引列</strong></span></p>
<p>在性能优化过程中，选择在哪些列上创建索引是最重要的步骤之一。可以考虑使用索引的主要有两种类型的列：在WHERE子句中出现的列，在join子句中出现的列。请看下面这个查询：</p>
<table border="1" cellspacing="0" cellpadding="2" width="550" align="center">
<tbody>
<tr>
<td bgcolor="#e6e6e6">
<pre>SELECT age ## 不使用索引 FROM people WHERE firstname='Mike' ## 考虑使用索引 AND
lastname='Sullivan' ## 考虑使用索引</pre>
</td>
</tr>
</tbody>
</table>
<p>这个查询与前面的查询略有不同，但仍属于简单查询。由于age是在SELECT部分被引用，MySQL不会用它来限制列选择操作。因此，对于这个查询来说，创建age列的索引没有什么必要。下面是一个更复杂的例子：</p>
<table border="1" cellspacing="0" cellpadding="2" width="550" align="center">
<tbody>
<tr>
<td bgcolor="#e6e6e6">
<pre>SELECT people.age, ##不使用索引 town.name ##不使用索引 FROM people LEFT JOIN town ON
people.townid=town.townid ##考虑使用索引 WHERE firstname='Mike' ##考虑使用索引 AND
lastname='Sullivan' ##考虑使用索引</pre>
</td>
</tr>
</tbody>
</table>
<p>与前面的例子一样，由于firstname和lastname出现在WHERE子句中，因此这两个列仍旧有创建索引的必要。除此之外，由于town表的townid列出现在join子句中，因此我们需要考虑创建该列的索引。</p>
<p>那 么，我们是否可以简单地认为应该索引WHERE子句和join子句中出现的每一个列呢？差不多如此，但并不完全。我们还必须考虑到对列进行比较的操作符类 型。MySQL只有对以下操作符才使用索引：&lt;，&lt;=，=，&gt;，&gt;=，BETWEEN，IN，以及某些时候的LIKE。可以在 LIKE操作中使用索引的情形是指另一个操作数不是以通配符（%或者_）开头的情形。例如，“SELECT peopleid FROM people WHERE firstname LIKE &#8216;Mich%&#8217;;”这个查询将使用索引，但“SELECT peopleid FROM people WHERE firstname LIKE &#8216;%ike&#8217;;”这个查询不会使用索引。</p>
<p><span style="color: #000099;"><strong style="font-size: 14pt;">分析索引效率</strong></span></p>
<p>现在我们已经知道了一些如何选择索引列的知识，但还无法判断哪一个最有效。MySQL提供了一个内建的SQL命令帮助我们完成这个任务，这就是EXPLAIN命令。EXPLAIN命令的一般语法是：EXPLAIN &lt;SQL命令&gt;。你可以在MySQL文档找到有关该命令的更多说明。下面是一个例子：</p>
<table border="1" cellspacing="0" cellpadding="2" width="550" align="center">
<tbody>
<tr>
<td bgcolor="#e6e6e6">
<pre>EXPLAIN SELECT peopleid FROM people WHERE firstname='Mike' AND lastname='Sullivan'
AND age='17';</pre>
</td>
</tr>
</tbody>
</table>
<p>这个命令将返回下面这种分析结果：</p>
<table border="1" width="502">
<tbody>
<tr>
<td>table</td>
<td>type</td>
<td>possible_keys</td>
<td>key</td>
<td>key_len</td>
<td>ref</td>
<td>rows</td>
<td>Extra</td>
</tr>
<tr>
<td>people</td>
<td>ref</td>
<td>fname_lname_age</td>
<td>fname_lname_age</td>
<td>102</td>
<td>const,const,const</td>
<td>1</td>
<td>Where used</td>
</tr>
</tbody>
</table>
<p>下面我们就来看看这个EXPLAIN分析结果的含义。</p>
<p>table：这是表的名字。</p>
<p>type：连接操作的类型。下面是MySQL文档关于ref连接类型的说明：</p>
<p>“对 于每一种与另一个表中记录的组合，MySQL将从当前的表读取所有带有匹配索引值的记录。如果连接操作只使用键的最左前缀，或者如果键不是UNIQUE或 PRIMARY KEY类型（换句话说，如果连接操作不能根据键值选择出唯一行），则MySQL使用ref连接类型。如果连接操作所用的键只匹配少量的记录，则ref是一 种好的连接类型。”</p>
<p>在本例中，由于索引不是UNIQUE类型，ref是我们能够得到的最好连接类型。</p>
<p>如果EXPLAIN显示连接类型是“ALL”，而且你并不想从表里面选择出大多数记录，那么MySQL的操作效率将非常低，因为它要扫描整个表。你可以加入更多的索引来解决这个问题。预知更多信息，请参见MySQL的手册说明。</p>
<p>possible_keys：</p>
<p>可能可以利用的索引的名字。这里的索引名字是创建索引时指定的索引昵称；如果索引没有昵称，则默认显示的是索引中第一个列的名字（在本例中，它是“firstname”）。默认索引名字的含义往往不是很明显。</p>
<p>Key：</p>
<p>它显示了MySQL实际使用的索引的名字。如果它为空（或NULL），则MySQL不使用索引。</p>
<p>key_len：</p>
<p>索引中被使用部分的长度，以字节计。在本例中，key_len是102，其中firstname占50字节，lastname占50字节，age占2字节。如果MySQL只使用索引中的firstname部分，则key_len将是50。</p>
<p>ref：</p>
<p>它显示的是列的名字（或单词“const”），MySQL将根据这些列来选择行。在本例中，MySQL根据三个常量选择行。</p>
<p><span style="font-size: small;">rows：</p>
<p>MySQL所认为的它在找到正确的结果之前必须扫描的记录数。显然，这里最理想的数字就是1。</p>
<p>Extra：</p>
<p>这里可能出现许多不同的选项，其中大多数将对查询产生负面影响。在本例中，MySQL只是提醒我们它将用WHERE子句限制搜索结果集。 </span></p>
<p><span style="font-size: small;"></p>
<p></span></p>
<p><span style="color: #000099;"><strong style="font-size: 14pt;">索引的缺点</strong></span></p>
<p>到目前为止，我们讨论的都是索引的优点。事实上，索引也是有缺点的。</p>
<p>首先，索引要占用磁盘空间。通常情况下，这个问题不是很突出。但是，如果你创建每一种可能列组合的索引，索引文件体积的增长速度将远远超过数据文件。如果你有一个很大的表，索引文件的大小可能达到<a href="http://www.xker.com/Html/czxt/index.html" target="_blank"><span style="color: #333333;">操作系统</span></a>允许的最大文件限制。</p>
<p>第二，对于需要写入数据的操作，比如DELETE、UPDATE以及INSERT操作，索引会降低它们的速度。这是因为MySQL不仅要把改动数据写入数据文件，而且它还要把这些改动写入索引文件。<br />
<strong>【结束语】</strong></p>
<p>在大型<a href="http://www.xker.com/Html/sjk/index.html" target="_blank"><span style="color: #333333;">数据库</span></a>中， 索引是提高速度的一个关键因素。不管表的结构是多么简单，一次500000行的表扫描操作无论如何不会快。如果你的网站上也有这种大规模的表，那么你确实 应该花些时间去分析可以采用哪些索引，并考虑是否可以改写查询以优化应用。要了解更多信息，请参见MySQL manual。另外注意，本文假定你所使用的MySQL是3.23版，部分查询不能在3.22版MySQL上执行</div>
]]></content:encoded>
			<wfw:commentRss>http://www.terrysco.com/node/mysql-index-opt.html/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>[转载]优化MySQL数据库性能</title>
		<link>http://www.terrysco.com/node/mysql-optimize.html</link>
		<comments>http://www.terrysco.com/node/mysql-optimize.html#comments</comments>
		<pubDate>Fri, 08 Jun 2007 20:12:50 +0000</pubDate>
		<dc:creator>terrysco</dc:creator>
				<category><![CDATA[Linux/Mac/DB]]></category>
		<category><![CDATA[mysql]]></category>

		<guid isPermaLink="false">http://www.anyliv.com/www.terrysco.com/?p=16</guid>
		<description><![CDATA[<p>本文从八个方面来讲解如何全新优化MySQL数据库性能。</p><p>　　<strong>1、选取最适用的字段属性</strong></p><p>　　MySQL可以很好的支持大数据量的存取，但是一般说来，数据库中的表越小，在它上面执行的查询也就会越快。因此，在创建表的时候，为了获得更 好的性能，我们可以将表中字段的宽度设得尽可能小。例如，在定义邮政编码这个字段时，如果将其设置为CHAR(255),显然给数据库增加了不必要的空 间，甚至使用VARCHAR这种类型也是多余的，因为CHAR(6)就可以很好的完成任务了。同样的，如果可以的话，我们应该使用MEDIUMINT而不 是BIGIN来定义整型字段。</p>...
]]></description>
			<content:encoded><![CDATA[<p>本文从八个方面来讲解如何全新优化MySQL数据库性能。</p>
<p>　　<strong>1、选取最适用的字段属性</strong></p>
<p>　　MySQL可以很好的支持大数据量的存取，但是一般说来，数据库中的表越小，在它上面执行的查询也就会越快。因此，在创建表的时候，为了获得更 好的性能，我们可以将表中字段的宽度设得尽可能小。例如，在定义邮政编码这个字段时，如果将其设置为CHAR(255),显然给数据库增加了不必要的空 间，甚至使用VARCHAR这种类型也是多余的，因为CHAR(6)就可以很好的完成任务了。同样的，如果可以的话，我们应该使用MEDIUMINT而不 是BIGIN来定义整型字段。</p>
<p>　　另外一个提高效率的方法是在可能的情况下，应该尽量把字段设置为NOT NULL，这样在将来执行查询的时候，数据库不用去比较NULL值。</p>
<p>　　对于某些文本字段，例如&ldquo;省份&rdquo;或者&ldquo;性别&rdquo;，我们可以将它们定义为ENUM类型。因为在MySQL中，ENUM类型被当作数值型数据来处理，而数值型数据被处理起来的速度要比文本类型快得多。这样，我们又可以提高数据库的性能。</p>
<p>　　<strong>2、使用连接（JOIN）来代替子查询(Sub-Queries)</strong></p>
<p>　　MySQL从4.1开始支持SQL的子查询。这个技术可以使用SELECT语句来创建一个单列的查询结果，然后把这个结果作为过滤条件用在另一 个查询中。例如，我们要将客户基本信息表中没有任何订单的客户删除掉，就可以利用子查询先从销售信息表中将所有发出订单的客户ID取出来，然后将结果传递 给主查询，如下所示：</p>
<p>　　DELETE FROM customerinfo</p>
<p>WHERE CustomerID NOT in (SELECT CustomerID FROM salesinfo )</p>
<p>　　使用子查询可以一次性的完成很多逻辑上需要多个步骤才能完成的SQL操作，同时也可以避免事务或者表锁死，并且写起来也很容易。但是，有些情况 下，子查询可以被更有效率的连接（JOIN）.. 替代。例如，假设我们要将所有没有订单记录的用户取出来，可以用下面这个查询完成：</p>
<p>　　SELECT * FROM customerinfo</p>
<p>WHERE CustomerID NOT in (SELECT CustomerID FROM salesinfo )</p>
<p>　　如果使用连接（JOIN）.. 来完成这个查询工作，速度将会快很多。尤其是当salesinfo表中对CustomerID建有索引的话，性能将会更好，查询如下：</p>
<p>　　SELECT * FROM customerinfo</p>
<p>LEFT JOIN salesinfoON customerinfo.CustomerID=salesinfo.</p>
<p>CustomerID</p>
<p>WHERE salesinfo.CustomerID IS NULL</p>
<p>　　连接（JOIN）.. 之所以更有效率一些，是因为 MySQL不需要在内存中创建临时表来完成这个逻辑上的需要两个步骤的查询工作。</p>
<p>　　<strong>3、使用联合(UNION)来代替手动创建的临时表</strong></p>
<p>　　MySQL 从 4.0 的版本开始支持 UNION 查询，它可以把需要使用临时表的两条或更多的 SELECT 查询合并的一个查询中。在客户端的查询会话结束的时候，临时表会被自动删除，从而保证数据库整齐、高效。使用 UNION 来创建查询的时候，我们只需要用 UNION作为关键字把多个 SELECT 语句连接起来就可以了，要注意的是所有 SELECT 语句中的字段数目要想同。下面的例子就演示了一个使用 UNION的查询。</p>
<p>　　SELECT Name, Phone FROM client</p>
<p>UNION</p>
<p>SELECT Name, BirthDate FROM author</p>
<p>UNION</p>
<p>SELECT Name, Supplier FROM product</p>
<p>　　<strong>4、事务</strong></p>
<p>　　尽管我们可以使用子查询（Sub-Queries）、连接（JOIN）和联合（UNION）来创建各种各样的查询，但不是所有的数据库操作都可 以只用一条或少数几条SQL语句就可以完成的。更多的时候是需要用到一系列的语句来完成某种工作。但是在这种情况下，当这个语句块中的某一条语句运行出错 的时候，整个语句块的操作就会变得不确定起来。设想一下，要把某个数据同时插入两个相关联的表中，可能会出现这样的情况：第一个表中成功更新后，数据库突 然出现意外状况，造成第二个表中的操作没有完成，这样，就会造成数据的不完整，甚至会破坏数据库中的数据。要避免这种情况，就应该使用事务，它的作用是： 要么语句块中每条语句都操作成功，要么都失败。换句话说，就是可以保持数据库中数据的一致性和完整性。事物以BEGIN 关键字开始，COMMIT关键字结束。在这之间的一条SQL操作失败，那么，ROLLBACK命令就可以把数据库恢复到BEGIN开始之前的状态。</p>
<p>　　BEGIN;</p>
<p>INSERT INTO salesinfo SET CustomerID=14;</p>
<p>UPDATE inventory SET Quantity=11</p>
<p>WHERE item=&#8217;book&#8217;;</p>
<p>COMMIT;</p>
<p>　　事务的另一个重要作用是当多个用户同时使用相同的数据源时，它可以利用锁定数据库的方法来为用户提供一种安全的访问方式，这样可以保证用户的操作不被其它的用户所干扰。</p>
<p>　　<strong>5、锁定表</strong></p>
<p>　　尽管事务是维护数据库完整性的一个非常好的方法，但却因为它的独占性，有时会影响数据库的性能，尤其是在很大的应用系统中。由于在事务执行的过程中，数据库将会被锁定，因此其它的用户请求只能暂时等待直到该事务结束。如果一个数据库系统只有少数几个用户</p>
<p>　　来使用，事务造成的影响不会成为一个太大的问题；但假设有成千上万的用户同时访问一个数据库系统，例如访问一个电子商务网站，就会产生比较严重的响应延迟。</p>
<p>　　其实，有些情况下我们可以通过锁定表的方法来获得更好的性能。下面的例子就用锁定表的方法来完成前面一个例子中事务的功能。</p>
<p>　　LOCK TABLE inventory WRITE</p>
<p>SELECT Quantity FROM inventory</p>
<p>WHEREItem=&#8217;book&#8217;;</p>
<p>&#8230;</p>
<p>UPDATE inventory SET Quantity=11</p>
<p>WHEREItem=&#8217;book&#8217;;</p>
<p>UNLOCK TABLES</p>
<p>　　这里，我们用一个 SELECT 语句取出初始数据，通过一些计算，用 UPDATE 语句将新值更新到表中。包含有 WRITE 关键字的 LOCK TABLE 语句可以保证在 UNLOCK TABLES 命令被执行之前，不会有其它的访问来对 inventory 进行插入、更新或者删除的操作。</p>
<p>　　<strong>6、使用外键</strong></p>
<p>　　锁定表的方法可以维护数据的完整性，但是它却不能保证数据的关联性。这个时候我们就可以使用外键。例如，外键可以保证每一条销售记录都指向某一 个存在的客户。在这里，外键可以把customerinfo 表中的CustomerID映射到salesinfo表中CustomerID，任何一条没有合法CustomerID的记录都不会被更新或插入到 salesinfo中。</p>
<p>　　CREATE TABLE customerinfo</p>
<p>(</p>
<p>CustomerID INT NOT NULL ,</p>
<p>PRIMARY KEY ( CustomerID )</p>
<p>) TYPE = INNODB;</p>
<p>CREATE TABLE salesinfo</p>
<p>(</p>
<p>SalesID INT NOT NULL,</p>
<p>CustomerID INT NOT NULL,</p>
<p>PRIMARY KEY(CustomerID, SalesID),</p>
<p>FOREIGN KEY (CustomerID) REFERENCES customerinfo</p>
<p>(CustomerID) ON DELETECASCADE</p>
<p>) TYPE = INNODB;</p>
<p>　　注意例子中的参数&ldquo;ON DELETE CASCADE&rdquo;。该参数保证当 customerinfo 表中的一条客户记录被删除的时候，salesinfo 表中所有与该客户相关的记录也会被自动删除。如果要在 MySQL 中使用外键，一定要记住在创建表的时候将表的类型定义为事务安全表 InnoDB类型。该类型不是 MySQL 表的默认类型。定义的方法是在 CREATE TABLE 语句中加上 TYPE=INNODB。如例中所示。</p>
<p>　　<strong>7、使用索引</strong></p>
<p>　　索引是提高数据库性能的常用方法，它可以令数据库服务器以比没有索引快得多的速度检索特定的行，尤其是在查询语句当中包含有MAX(), MIN()和ORDERBY这些命令的时候，性能提高<br />
更为明显。那该对哪些字段建立索引呢？一般说来，索引应建立在那些将用于JOIN, WHERE判断和ORDER BY排序的字段上。尽量不要对数据库中某个含有大量重复的值的字段建立索引。对于一个ENUM类型的字段来说，出现大量重复值是很有可能的情况，例如 customerinfo中的&ldquo;province&rdquo;.. 字段，在这样的字段上建立索引将不会有什么帮助；相反，还有可能降低数据库的性能。我们在创建表的时候可以同时创建合适的索引，也可以使用ALTER TABLE或CREATE INDEX在以后创建索引。此外，MySQL</p>
<p>　　从版本3.23.23开始支持全文索引和搜索。全文索引在MySQL 中是一个FULLTEXT类型索引，但仅能用于MyISAM 类型的表。对于一个大的数据库，将数据装载到一个没有FULLTEXT索引的表中，然后再使用ALTER TABLE或CREATE INDEX创建索引，将是非常快的。但如果将数据装载到一个已经有FULLTEXT索引的表中，执行过程将会非常慢。</p>
<p>　　<strong>8、优化的查询语句</strong></p>
<p>　　绝大多数情况下，使用索引可以提高查询的速度，但如果SQL语句使用不恰当的话，索引将无法发挥它应有的作用。下面是应该注意的几个方面。首 先，最好是在相同类型的字段间进行比较的操作。在MySQL 3.23版之前，这甚至是一个必须的条件。例如不能将一个建有索引的INT字段和BIGINT字段进行比较；但是作为特殊的情况，在CHAR类型的字段和 VARCHAR类型字段的字段大小相同的时候，可以将它们进行比较。其次，在建有索引的字段上尽量不要使用函数进行操作。</p>
<p>　　例如，在一个DATE类型的字段上使用YEAE()函数时，将会使索引不能发挥应有的作用。所以，下面的两个查询虽然返回的结果一样，但后者要比前者快得多。</p>
<p>　　SELECT * FROM order WHERE YEAR(OrderDate)&lt;2001;</p>
<p>SELECT * FROM order WHERE OrderDate&lt;&quot;2001-01-01&quot;;</p>
<p>　　同样的情形也会发生在对数值型字段进行计算的时候：</p>
<p>　　SELECT * FROM inventory WHERE Amount/7&lt;24;</p>
<p>SELECT * FROM inventory WHERE Amount&lt;24*7;</p>
<p>　　上面的两个查询也是返回相同的结果，但后面的查询将比前面的一个快很多。第三，在搜索字符型字段时，我们有时会使用 LIKE 关键字和通配符，这种做法虽然简单，但却也是以牺牲系统性能为代价的。例如下面的查询将会比较表中的每一条记录。</p>
<p>　　SELECT * FROM books</p>
<p>WHERE name like &quot;MySQL%&quot;</p>
<p>　　但是如果换用下面的查询，返回的结果一样，但速度就要快上很多：</p>
<p>　　SELECT * FROM books</p>
<p>WHERE name&gt;=&quot;MySQL&quot;and name&lt;&quot;MySQM&quot;</p>
<p>　　最后，应该注意避免在查询中让MySQL进行自动类型转换，因为转换过程也会使索引变得不起作用。</p>
]]></content:encoded>
			<wfw:commentRss>http://www.terrysco.com/node/mysql-optimize.html/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
	</channel>
</rss>

