mysql 基本使用教程(源于网络)
2013-10-11 18:16
736 查看
http://dev.mysql.com/doc/refman/5.1/zh/index.html3.1.连接与断开服务器3.2.输入查询3.3.创建并使用数据库3.3.1.创建并选择数据库3.3.2.创建表3.3.3.将数据装入表中3.3.4.从表检索信息3.4.获得数据库和表的信息3.5.在批处理模式下使用mysql3.6.常用查询的例子3.6.1.列的最大值3.6.2.拥有某个列的最大值的行3.6.3.列的最大值：按组3.6.4.拥有某个字段的组间最大值的行3.6.5.使用用户变量3.6.6.使用外键3.6.7.根据两个键搜索3.6.8.根据天计算访问量3.6.9.使用AUTO_INCREMENT3.7.孪生项目的查询3.7.1.查找所有未分发的孪生项3.7.2.显示孪生对状态的表3.8.与Apache一起使用MySQL
本章通过演示如何使用mysql客户程序创造和使用一个简单的数据库，提供一个MySQL的入门教程。mysql（有时称为“终端监视器”或只是“监视”）是一个交互式程序，允许你连接一个MySQL服务器，运行查询并察看结果。mysql可以用于批模式：你预先把查询放在一个文件中，然后告诉mysql执行文件的内容。本章将介绍使用mysql的两个方法。
要想查看由mysql提供的选择项目表，可以用--help选项来调用：
本章假定mysql已经被安装在你的机器上，并且有一个MySQL服务器可以连接。否则，请联络MySQL管理员。（如果你是管理员，则需要查阅本手册的其它章节，例如第5章：数据库管理。）
本章描述建立和使用一个数据库的全过程。如果你仅仅对访问一个已经存在的数据库感兴趣，可以跳过描述怎样创建数据库及它所包含的表的章节。
由于本章是一个教程，省略了许多细节。关于这里所涉及的主题的详细信息，请查阅本手册的相关章节。
host和user分别代表MySQL服务器运行的主机名和MySQL账户用户名。设置时替换为正确的值。********代表你的密码；当mysql显示Enterpassword:提示时输入它。
如果有效，你应该看见mysql>提示符后的一些介绍信息：
mysql>提示符告诉你mysql准备为你输入命令。
一些MySQL安装允许用户以匿名（未命名）用户连接到本地主机上运行的服务器。如果你的机器是这种情况，你应该能不带任何选项地调用mysql与该服务器连接：
成功地连接后，可以在mysql>提示下输入QUIT(或/q)随时退出：
在Unix中，也可以按control-D键断开服务器。
在下列章节的大多数例子都假设你连接到了服务器。由mysql>提示指明。
这是一个简单的命令，要求服务器告诉它的版本号和当前日期。在mysql>提示输入如下命令并按回车键：
这询问说明mysql的几个方面:
·一个命令通常由SQL语句组成，随后跟着一个分号。（有一些例外不需要分号。早先提到的QUIT是一个例子。后面我们将看到其它的例子。）
·当发出一个命令时，mysql将它发送给服务器并显示执行结果，然后显示另一个mysql>显示它准备好接受其它命令。
·mysql用表格(行和列)方式显示查询输出。第一行包含列的标签，随后的行是查询结果。通常，列标签是你取自数据库表的列的名字。如果你正在检索一个表达式而非表列的值(如刚才的例子)，mysql用表达式本身标记列。
·mysql显示返回了多少行，以及查询花了多长时间，它给你提供服务器性能的一个大致概念。因为他们表示时钟时间(不是CPU或机器时间)，并且因为他们受到诸如服务器负载和网络延时的影响，因此这些值是不精确的。（为了简洁，在本章其它例子中不再显示“集合中的行”。）
能够以大小写输入关键词。下列查询是等价的：
这是另外一个查询，它说明你能将mysql用作一个简单的计算器：
至此显示的命令是相当短的单行语句。你可以在一行上输入多条语句，只需要以一个分号间隔开各语句：
不必全在一个行内给出一个命令，较长命令可以输入到多个行中。mysql通过寻找终止分号而不是输入行的结束来决定语句在哪儿结束。（换句话说，mysql接受自由格式的输入：它收集输入行但直到看见分号才执行。）
这里是一个简单的多行语句的例子：
在这个例子中，在输入多行查询的第一行后，要注意提示符如何从mysql>变为->，这正是mysql如何指出它没见到完整的语句并且正在等待剩余的部分。提示符是你的朋友，因为它提供有价值的反馈，如果使用该反馈，将总是知道mysql正在等待什么。
如果你决定不想执行正在输入过程中的一个命令，输入/c取消它：
这里也要注意提示符，在你输入/c以后，它切换回到mysql>，提供反馈以表明mysql准备接受一个新命令。
下表显示出可以看见的各个提示符并简述它们所表示的mysql的状态：
当你打算在一个单行上发出一个命令时，通常会“偶然”出现多行语句，但是没有终止分号。在这种情况中，mysql等待进一步输入：
如果出现这种情况(你认为输完了语句，但是只有一个->提示符响应)，很可能mysql正在等待分号。如果你没有注意到提示符的提示，在意识到你需要做什么之前，你可能会呆坐一会儿。输入一个分号完成语句，mysql将执行：
在字符串收集期间将出现'>和">提示符（提示MySQL正等待字符串的结束）。在MySQL中，可以写由‘'’或‘"’字符括起来的字符串(例如，'hello'或"goodbye")，并且mysql允许输入跨越多行的字符串。当看到一个'>或">提示符时，这意味着已经输入了包含以‘'’或‘"’括号字符开始的字符串的一行，但是还没有输入终止字符串的匹配引号。这显示你粗心地省掉了一个引号字符。例如：
如果你输入SELECT语句，然后按Enter（回车）键并等待结果，什么都没有出现。不要惊讶，“为什么该查询这么长呢？”，注意">提示符提供的线索。它告诉你mysql期望见到一个未终止字符串的余下部分。（你看见语句中的错误吗？字符串"Smith丢掉了第二个引号。）
走到这一步，你该做什么？最简单的是取消命令。然而，在这种情况下，你不能只是输入/c，因为mysql作为它正在收集的字符串的一部分来解释它！相反，应输入关闭的引号字符(这样mysql知道你完成了字符串)，然后输入/c：
提示符回到mysql>，显示mysql准备好接受一个新命令了。
`>提示符类似于'>和">提示符，但表示你已经开始但没有结束以`>开始的识别符。
知道'>和">提示符的含义很重要，因为如果你错误地输入一个未终止的字符串，任何后面输入的行将要被mysql忽略--包括包含QUIT的行！这可能令人相当困惑，特别是如果取消当前命令前还不知道你需要提供终止引号。
3.3.1.创建并选择数据库3.3.2.创建表3.3.3.将数据装入表中3.3.4.从表检索信息
知道怎样输入命令，便可以访问数据库了。
假定在你的家(你的“动物园”)中有很多宠物，并且你想跟踪关于它们各种类型的信息。你可以通过创建表来保存你的数据并根据所需要的信息装载他们，然后你可以从表中检索数据来回答关于动物不同种类的问题。本节显示如何做到所有这些事情：
·创建数据库
·创建数据库表
·装载数据到数据库表
·以各种方法从表中检索数据
·使用多个表
动物园数据库很简单(特意的)，但是不难把它想象成可能用到类似数据库的真实世界情况。例如，农夫可以使用这样的一个数据库来追踪家畜，或者兽医可以用它跟踪病畜记录。从MySQL网址上可以获得后面章节中将用到的含有部分查询和样例数据的动物园分发。有tar压缩格式(http://downloads.mysql.com/docs/menagerie-db.tar.gz)和Zip压缩格式(http://downloads.mysql.com/docs/menagerie-db.zip)。
使用SHOW语句找出服务器上当前存在什么数据库：
可能你的机器上的数据库列表是不同的，但是很可能有mysql和test数据库。mysql是必需的，因为它描述用户访问权限，test数据库经常作为用户试身手的工作区。
请注意如果没有SHOWDATABASES权限，则不能看见所有数据库。参见13.5.1.3节，“GRANT和REVOKE语法”。
如果test数据库存在，尝试访问它：
注意，USE，类似QUIT，不需要一个分号。（如果你喜欢，你可以用一个分号终止这样的语句；这无碍）USE语句在使用上也有另外一个特殊的地方：它必须在一个单行上给出。
你可列在后面的例子中使用test数据库(如果你能访问它)，但是你在该数据库创建的任何东西可以被访问它的其它人删除，因此，你应该询问MySQL管理员许可你使用自己的一个数据库。假定你想要调用你的menagerie，管理员需要执行这样一条命令：
这里your_mysql_name是分配给你的MySQL用户名，your_client_host是所连接的服务器所在的主机。
在Unix下，数据库名称是区分大小写的(不像SQL关键字)，因此你必须总是以menagerie访问数据库，而不能用Menagerie、MENAGERIE或其它一些变量。对表名也是这样的。（在Windows下，该限制不适用，尽管你必须在一个给定的查询中使用同样的大小写来引用数据库和表。但是，由于多种原因，作为最好的惯例，一定要使用与数据库创建时的同样的大小写。）
创建数据库并不表示选定并使用它，你必须明确地操作。为了使menagerie成为当前的数据库，使用这个命令：
数据库只需要创建一次，但是必须在每次启动mysql会话时在使用前先选择它。你可以根据上面的例子执行一个USE语句来实现。还可以在调用mysql时，通过命令行选择数据库，只需要在提供连接参数之后指定数据库名称。例如：
注意，刚才显示的命令行中的menagerie不是你的密码。如果你想要在命令行上在-p选项后提供密码，则不能插入空格(例如，如-pmypassword，不是-pmypassword)。但是，不建议在命令行输入密码，因为这样会暴露密码，能被在机器上登录的其它用户窥探到。
较难的部分是决定你的数据库结构应该是什么：你需要什么数据库表，各数据库表中有什么样的列。
你将需要一个包含你每个宠物的记录的表。它可称为pet表，并且它应该包含，最少，每个动物的名字。因为名字本身不是很有趣，表应该包含另外的信息。例如，如果在你豢养宠物的家庭有超过一个人，你可能想要列出每个动物的主人。你可能也想要记录例如种类和性别的一些基本的描述信息。
年龄呢？那可能有趣，但是存储到一个数据库中不是一件好事情。年龄随着时间流逝而变化，这意味着你将要不断地更新你的记录。相反,存储一个固定值例如生日比较好，那么，无论何时你需要年龄，可以以当前日期和出生日期之间的差来计算它。MySQL提供了日期运算函数，因此这并不困难。存储出生日期而非年龄还有其它优点：
·你可以使用数据库完成这样的任务，例如生成即将到来的宠物生日的提示。（如果你认为这类查询有点蠢，注意，这与从商务数据库来识别出不久要发给生日祝贺的客户是同一个问题，因为计算机帮助私人联络。）
·你可以相对于日期而不止是当前日期来计算年龄。例如，如果你在数据库存储死亡日期，你能很容易地计算出一只宠物死时有多大。
你可能想到pet表中其它有用的其它类型信息，但是到目前为止这些已经足够了：名字、主人、种类，性别、出生和死亡日期。
使用一个CREATETABLE语句指定你的数据库表的布局：
VARCHAR适合于name、owner和species列，因为列值是变长的。这些列的长度不必都相同，而且不必是20。你可以挑选从1到65535的任何长度，从中选择一个最合理的值。（如果选择得不合适，后来证明你需要一个更长的字段，MySQL提供一个ALTERTABLE语句。）
可以用多种类型的值来表示动物记录中的性别，例如，"m"和"f"，或"male"和"female"。使用单字符"m"和"f"是最简单的方法。
很显然，birth和death列应选用DATE数据类。
创建了数据库表后，SHOWTABLES应该产生一些输出：
为了验证你的表是按你期望的方式创建，使用一个DESCRIBE语句：
你可以随时使用DESCRIBE，例如，如果你忘记表中的列的名称或类型时。
假定你的宠物纪录描述如下。（假定在MySQL中期望的日期格式是YYYY-MM-DD；这可能与你习惯的不同。）
因为你是从一个空表开始的，填充它的一个简易方法是创建一个文本文件，每个动物各一行，然后用一个语句将文件的内容装载到表中。
你可以创建一个文本文件“pet.txt”，每行包含一个记录，用定位符(tab)把值分开，并且以CREATETABLE语句中列出的列次序给出。对于丢失的值(例如未知的性别，或仍然活着的动物的死亡日期)，你可以使用NULL值。为了在你的文本文件中表示这些内容，使用/N（反斜线，字母N）。例如，Whistler鸟的记录应为(这里值之间的空白是一个定位符)：
要想将文本文件“pet.txt”装载到pet表中，使用这个命令：
请注意如果用Windows中的编辑器（使用/r/n做为行的结束符）创建文件，应使用：
（在运行OSX的Apple机上，应使用行结束符'/r'。）
如果你愿意，你能明确地在LOADDATA语句中指出列值的分隔符和行尾标记，但是默认标记是定位符和换行符。这对读入文件“pet.txt”的语句已经足够。
如果该语句失败，可能是你安装的MySQL不与使用默认值的本地文件兼容。关于如何更改请参见5.6.4节，“LOADDATALOCAL安全问题”。
如果想要一次增加一个新记录，可以使用INSERT语句。最简单的形式是，提供每一列的值，其顺序与CREATETABLE语句中列的顺序相同。假定Diane把一只新仓鼠命名为Puffball，你可以使用下面的INSERT语句添加一条新记录：
注意，这里字符串和日期值均为引号扩起来的字符串。另外，可以直接用INSERT语句插入NULL代表不存在的值。不能使用LOADDATA中所示的的/N。
从这个例子，你应该能看到涉及很多的键入用多个INSERT语句而非单个LOADDATA语句装载你的初始记录。
3.3.4.1.选择所有数据3.3.4.2.选择特殊行3.3.4.3.选择特殊列3.3.4.4.分类行3.3.4.5.日期计算3.3.4.6.NULL值操作3.3.4.7.模式匹配3.3.4.8.计数行3.3.4.9.使用1个以上的表
SELECT语句用来从数据表中检索信息。语句的一般格式是：
what_to_select指出你想要看到的内容，可以是列的一个表，或*表示“所有的列”。which_table指出你想要从其检索数据的表。WHERE子句是可选项，如果选择该项，conditions_to_satisfy指定行必须满足的检索条件。
如果你想要浏览整个表，可以使用这种形式的SELECT，例如，刚刚装载了初始数据集以后。也有可能你想到Bowser的生日看起来不很对。查阅你原来的家谱，你发现正确的出生年是1989，而不是1979。
至少有两种修正方法：
·编辑文件“pet.txt”改正错误，然后使用DELETE和LOADDATA清空并重新装载表:
然而,如果这样操做，必须重新输入Puffball记录。
·用一个UPDATE语句仅修正错误记录：
UPDATE只更改有问题的记录，不需要重新装载数据库表。
可以从表中只选择特定的行。例如，如果你想要验证你对Bowser的生日所做的更改，按下述方法选择Bowser的记录：
输出证实正确的年份记录为1989，而不是1979。
字符串比较时通常对大小些不敏感，因此你可以将名字指定为"bowser"、"BOWSER"等，查询结果相同。
你可以在任何列上指定条件，不只仅仅是name。例如，如果你想要知道哪个动物在1998以后出生的，测试birth列：
可以组合条件，例如，找出雌性的狗：
上面的查询使用AND逻辑操作符，也有一个OR操作符：
AND和OR可以混用，但AND比OR具有更高的优先级。如果你使用两个操作符，使用圆括号指明如何对条件进行分组是一个好主意：
找出谁拥有宠物，使用这个查询：
请注意该查询只是简单地检索每个记录的owner列，并且他们中的一些出现多次。为了使输出减到最少，增加关键字DISTINCT检索出每个唯一的输出记录：
可以使用一个WHERE子句结合行选择与列选择。例如，要想查询狗和猫的出生日期，使用这个查询：
这里是动物生日，按日期排序：
在字符类型列上，与所有其他比较操作类似，分类功能正常情况下是以区分大小写的方式执行的。这意味着，对于等同但大小写不同的列，并未定义其顺序。对于某一列，可以使用BINARY强制执行区分大小写的分类功能，如：ORDERBYBINARYcol_name.
默认排序是升序，最小的值在第一。要想以降序排序，在你正在排序的列名上增加DESC（降序）关键字：
可以对多个列进行排序，并且可以按不同的方向对不同的列进行排序。例如，按升序对动物的种类进行排序，然后按降序根据生日对各动物种类进行排序（最年轻的动物在最前面），使用下列查询：
注意DESC关键字仅适用于在它前面的列名(birth)；不影响species列的排序顺序。
要想确定每个宠物有多大，可以计算当前日期的年和出生日期之间的差。如果当前日期的日历年比出生日期早，则减去一年。以下查询显示了每个宠物的出生日期、当前日期和年龄数值的年数字。
此处，YEAR()提取日期的年部分，RIGHT()提取日期的MM-DD(日历年)部分的最右面5个字符。比较MM-DD值的表达式部分的值一般为1或0，如果CURDATE()的年比birth的年早，则年份应减去1。整个表达式有些难懂，使用alias(age)来使输出的列标记更有意义。
尽管查询可行，如果以某个顺序排列行，则能更容易地浏览结果。添加ORDERBYname子句按照名字对输出进行排序则能够实现。
为了按age而非name排序输出，只要再使用一个ORDERBY子句：
可以使用一个类似的查询来确定已经死亡动物的死亡年龄。你通过检查death值是否是NULL来确定是哪些动物，然后，对于那些非NULL值的动物，需要计算出death和birth值之间的差：
查询使用deathISNOTNULL而非death!=NULL，因为NULL是特殊的值，不能使用普通比较符来比较，以后会给出解释。参见3.3.4.6节，“NULL值操作”。
如果你想要知道哪个动物下个月过生日，怎么办？对于这类计算，年和天是无关的，你只需要提取birth列的月份部分。MySQL提供几个日期部分的提取函数，例如YEAR()、MONTH()和DAYOFMONTH()。在这里MONTH()是适合的函数。为了看它怎样工作，运行一个简单的查询，显示birth和MONTH(birth)的值：
找出下个月生日的动物也是容易的。假定当前月是4月，那么月值是4，你可以找在5月出生的动物(5月)，方法是：
如果当前月份是12月，就有点复杂了。你不能只把1加到月份数(12)上并寻找在13月出生的动物，因为没有这样的月份。相反，你应寻找在1月出生的动物(1月)。
你甚至可以编写查询，不管当前月份是什么它都能工作。采用这种方法不必在查询中使用一个特定的月份，DATE_ADD()允许在一个给定的日期上加上时间间隔。如果在NOW()值上加上一个月，然后用MONTH()提取月份，结果产生生日所在月份：
完成该任务的另一个方法是加1以得出当前月份的下一个月(在使用取模函数(MOD)后，如果月份当前值是12，则“回滚”到值0)：
注意，MONTH返回在1和12之间的一个数字，且MOD(something,12)返回在0和11之间的一个数字，因此必须在MOD()以后加1，否则我们将从11月(11)跳到1月(1)。
很显然你不能通过这些比较得到有意义的结果。相反使用ISNULL和ISNOTNULL操作符：
请注意在MySQL中，0或NULL意味着假而其它值意味着真。布尔运算的默认真值是1。
对NULL的特殊处理即是在前面的章节中，为了决定哪个动物不再是活着的，使用deathISNOTNULL而不使用death!=NULL的原因。
在GROUPBY中，两个NULL值视为相同。
执行ORDERBY时，如果运行ORDERBY...ASC，则NULL值出现在最前面，若运行ORDERBY...DESC，则NULL值出现在最后面。
NULL操作的常见错误是不能在定义为NOTNULL的列内插入0或空字符串，但事实并非如此。在NULL表示"没有数值"的地方有数值。使用IS[NOT]NULL则可以很容易地进行测试，如下所示：
因此完全可以在定义为NOTNULL的列内插入0或空字符串，实际是NOTNULL。参见A.5.3节，“与NULL值有关的问题”。
SQL模式匹配允许你使用“_”匹配任何单个字符，而“%”匹配任意数目字符(包括零字符)。在MySQL中，SQL的模式默认是忽略大小写的。下面给出一些例子。注意使用SQL模式时，不能使用=或!=；而应使用LIKE或NOTLIKE比较操作符。
要想找出以“b”开头的名字：
要想找出以“fy”结尾的名字：
要想找出包含“w”的名字：
要想找出正好包含5个字符的名字，使用“_”模式字符：
由MySQL提供的模式匹配的其它类型是使用扩展正则表达式。当你对这类模式进行匹配测试时，使用REGEXP和NOTREGEXP操作符(或RLIKE和NOTRLIKE，它们是同义词)。
扩展正则表达式的一些字符是：
·‘.’匹配任何单个的字符。
·字符类“[...]”匹配在方括号内的任何字符。例如，“[abc]”匹配“a”、“b”或“c”。为了命名字符的范围，使用一个“-”。“[a-z]”匹配任何字母，而“[0-9]”匹配任何数字。
·“*”匹配零个或多个在它前面的字符。例如，“x*”匹配任何数量的“x”字符，“[0-9]*”匹配任何数量的数字，而“.*”匹配任何数量的任何字符。
如果REGEXP模式与被测试值的任何地方匹配，模式就匹配(这不同于LIKE模式匹配，只有与整个值匹配，模式才匹配)。
为了定位一个模式以便它必须匹配被测试值的开始或结尾，在模式开始处使用“^”或在模式的结尾用“$”。
为了说明扩展正则表达式如何工作，下面使用REGEXP重写上面所示的LIKE查询：
为了找出以“b”开头的名字，使用“^”匹配名字的开始：
如果你想强制使REGEXP比较区分大小写，使用BINARY关键字使其中一个字符串变为二进制字符串。该查询只匹配名称首字母的小写‘b’。
为了找出以“fy”结尾的名字，使用“$”匹配名字的结尾：
为了找出包含一个“w”的名字，使用以下查询：
既然如果一个正则表达式出现在值的任何地方，其模式匹配了，就不必在先前的查询中在模式的两侧放置一个通配符以使得它匹配整个值，就像你使用了一个SQL模式那样。
为了找出包含正好5个字符的名字，使用“^”和“$”匹配名字的开始和结尾，和5个“.”实例在两者之间：
你也可以使用“{n}”“重复n次”操作符重写前面的查询：
附录G：MySQL正则表达式提供了关于正则表达式的句法的详细信息。
计算你拥有动物的总数目与“在pet表中有多少行?”是同样的问题，因为每个宠物有一个记录。COUNT(*)函数计算行数，所以计算动物数目的查询应为：
在前面，你检索了拥有宠物的人的名字。如果你想要知道每个主人有多少宠物，你可以使用COUNT()函数：
注意，使用GROUPBY对每个owner的所有记录分组，没有它，你会得到错误消息：
COUNT()和GROUPBY以各种方式分类你的数据。下列例子显示出进行动物普查操作的不同方式。
每种动物的数量：
每种性别的动物数量：
（在这个输出中，NULL表示“未知性别”。）
按种类和性别组合的动物数量：
若使用COUNT()，你不必检索整个表。例如,前面的查询，当只对狗和猫进行时，应为：
或，如果你仅需要知道已知性别的按性别的动物数目：
3.3.4.9.使用1个以上的表
pet表追踪你有哪个宠物。如果你想要记录其它相关信息，例如在他们一生中看兽医或何时后代出生，你需要另外的表。这张表应该像什么呢？需要：
·它需要包含宠物名字以便你知道每个事件属于哪个动物。
·需要一个日期以便你知道事件是什么时候发生的。
·需要一个描述事件的字段。
·如果你想要对事件进行分类，则需要一个事件类型字段。
综合上述因素，event表的CREATETABLE语句应为：
对于pet表，最容易的方法是创建包含信息的用定位符分隔的文本文件来装载初始记录：
采用如下方式装载记录：
根据你从已经运行在pet表上的查询中学到的，你应该能执行对event表中记录的检索；原理是一样的。但是什么时候event表本身不能回答你可能问的问题呢？
当他们有了一窝小动物时，假定你想要找出每只宠物的年龄。我们前面看到了如何通过两个日期计算年龄。event表中有母亲的生产日期，但是为了计算母亲的年龄，你需要她的出生日期，存储在pet表中。说明查询需要两个表：
关于该查询要注意的几件事情：
FROM子句列出两个表，因为查询需要从两个表提取信息。
当从多个表组合(联结)信息时，你需要指定一个表中的记录怎样能匹配其它表的记录。这很简单，因为它们都有一个name列。查询使用WHERE子句基于name值来匹配2个表中的记录。
因为name列出现在两个表中，当引用列时，你一定要指定哪个表。把表名附在列名前即可以实现。
你不必有2个不同的表来进行联结。如果你想要将一个表的记录与同一个表的其它记录进行比较，可以将一个表联结到自身。例如，为了在你的宠物之中繁殖配偶，你可以用pet联结自身来进行相似种类的雄雌配对：
在这个查询中，我们为表名指定别名以便能引用列并且使得每一个列引用与哪个表实例相关联更直观。
你已经见到了SHOWDATABASES，它列出由服务器管理的数据库。为了找出当前选择了哪个数据库，使用DATABASE()函数：
如果你还没选择任何数据库，结果是NULL。
为了找出当前的数据库包含什么表(例如，当你不能确定一个表的名字)，使用这个命令：
如果你想要知道一个表的结构，可以使用DESCRIBE命令；它显示表中每个列的信息：
Field显示列名字，Type是列的数据类型，Null表示列是否能包含NULL值，Key显示列是否被索引而Default指定列的默认值。
如果表有索引，SHOWINDEXFROMtbl_name生成有关索引的信息。
如果在Windows下运行mysql，并且文件中有一些可以造成问题的特殊字符，可以这样操作：
如果你需要在命令行上指定连接参数，命令应为：
当这样操作mysql时，则创建一个脚本文件，然后执行脚本。
如果你想在语句出现错误的时候仍想继续执行脚本，则应使用--force命令行选项。
为什么要使用一个脚本？有很多原因：
如果你需要重复运行查询(比如说，每天或每周)，可以把它编成一个脚本，则每次执行时不必重新键入。
可以通过拷贝并编辑脚本文件从类似的现有的查询生成一个新查询。
当你正在开发查询时，批模式也是很有用的，特别对多行命令或多语句命令序列。如果你犯了一个错误，你不必重新输入所有内容，只需要编辑脚本来改正错误，然后告诉mysql再次执行脚本。
如果你有一个产生多个输出的查询，你可以通过一个分页器而不是盯着它翻屏到屏幕的顶端来运行输出：
你可以捕捉文件中的输出以便进行进一步的处理：
你可以将脚本分发给另外的人，以便他们也能运行命令。
某些情况不允许交互地使用，例如,当你从一个cron任务中运行查询时。在这种情况下，你必须使用批模式。
当你以批模式运行mysql时，比起你交互地使用它时，其默认输出格式是不同的(更简明些)。例如，当交互式运行SELECTDISTINCTspeciesFROMpet时，输出应为：
但是当以批模式运行时，输出应为：
如果你想要在批模式中得到交互输出格式，使用mysql-t。为了回显以输出被执行的命令，使用mysql-vvv。
你还可以使用源代码或/.命令从mysql提示符运行脚本：
3.6.1.列的最大值3.6.2.拥有某个列的最大值的行3.6.3.列的最大值：按组3.6.4.拥有某个字段的组间最大值的行3.6.5.使用用户变量3.6.6.使用外键3.6.7.根据两个键搜索3.6.8.根据天计算访问量3.6.9.使用AUTO_INCREMENT
下面是一些学习如何用MySQL解决一些常见问题的例子。
在一些例子中，使用数据库表“shop”来储存某个商人（经销商）的每件物品(物品号)的价格。假定每个商人对每项物品有一个固定价格，那么(物品，商人)即为该记录的主关键字。
启动命令行工具mysql并选择数据库：
（在大多数MySQL中，你可以使用test数据库）。
你可以使用以下语句创建示例表：
执行语句后，表应包含以下内容：
SELECTMAX(article)ASarticleFROMshop;
+---------+
|article|
+---------+
|4|
+---------+
这很容易用一个子查询做到：
另一个解决方案是按价格降序排序所有行并用MySQL特定LIMIT子句只得到第一行：
注:如果有多项最贵的物品(例如每个的价格为19.95)，LIMIT解决方案仅仅显示其中一个！
SELECTarticle,MAX(price)ASprice
FROMshop
GROUPBYarticle
+---------+-------+
|article|price|
+---------+-------+
|0001|3.99|
|0002|10.99|
|0003|1.69|
|0004|19.95|
+---------+-------+
可以用这样一个子查询解决该问题：
SELECTarticle,dealer,price
FROMshops1
WHEREprice=(SELECTMAX(s2.price)
FROMshops2
WHEREs1.article=s2.article);
9.3节，“用户变量”.）。
例如，要找出价格最高或最低的物品的，其方法是：
mysql>SELECT@min_price:=MIN(price),@max_price:=MAX(price)FROMshop;
mysql>SELECT*FROMshopWHEREprice=@min_priceORprice=@max_price;
+---------+--------+-------+
|article|dealer|price|
+---------+--------+-------+
|0003|D|1.25|
|0004|D|19.95|
+---------+--------+-------+
15.2节，“InnoDB存储引擎”。还可以参见1.8.5.5节，“外键”。
只是联接两个表时，不需要外部关键字。对于除InnoDB类型的表，当使用REFERENCEStbl_name(col_name)子句定义列时可以使用外部关键字，该子句没有实际的效果，只作为备忘录或注释来提醒，你目前正定义的列指向另一个表中的一个列。执行该语句时，实现下面很重要：
·MySQL不执行表tbl_name中的动作，例如作为你正定义的表中的行的动作的响应而删除行；换句话说，该句法不会致使ONDELETE或ONUPDATE行为（如果你在REFERENCES子句中写入ONDELETE或ONUPDATE子句，将被忽略）。
·该句法可以创建一个column；但不创建任何索引或关键字。
·如果用该句法定义InnoDB表，将会导致错误。
你可以使用作为联接列创建的列，如下所示：
按照这种方式使用，REFERENCES子句不会显示在SHOWCREATETABLE或DESCRIBE的输出中:
在列定义中，按这种方式使用REFERENCES作为注释或“提示”适用于表MyISAM和BerkeleyDB。
一个比较灵活的例子是寻找两个通过OR组合到一起的关键字：
该情形是已经优化过的。参见7.2.6节，“索引合并优化”。
还可以使用UNION将两个单独的SELECT语句的输出合成到一起来更有效地解决该问题。参见13.2.7.2节，“UNION语法
”。
每个SELECT只搜索一个关键字，可以进行优化：
示例表中含有代表用户访问网页的年－月－日值。可以使用以下查询来确定每个月的访问天数：
将返回：
该查询计算了在表中按年/月组合的不同天数，可以自动去除重复的询问。
将返回：
你可以使用LAST_INSERT_ID()SQL函数或mysql_insert_id()CAPI函数来查询最新的AUTO_INCREMENT值。这些函数与具体连接有关，因此其返回值不会被其它执行插入功能的连接影响。
注释：对于多行插入，LAST_INSERT_ID()和mysql_insert_id()从插入的第一行实际返回AUTO_INCREMENT关键字。在复制设置中，通过该函数可以在其它服务器上正确复制多行插入。
对于MyISAM和BDB表，你可以在第二栏指定AUTO_INCREMENT以及多列索引。此时，AUTO_INCREMENT列生成的值的计算方法为：MAX(auto_increment_column)+1WHEREprefix=given-prefix。如果想要将数据放入到排序的组中可以使用该方法。
将返回：
请注意在这种情况下（AUTO_INCREMENT列是多列索引的一部分），如果你在任何组中删除有最大AUTO_INCREMENT值的行，将会重新用到AUTO_INCREMENT值。对于MyISAM表也如此,对于该表一般不重复使用AUTO_INCREMENT值。
如果AUTO_INCREMENT列是多索引的一部分，MySQL将使用该索引生成以AUTO_INCREMENT列开始的序列值。。例如，如果animals表含有索引PRIMARYKEY(grp,id)和INDEX(id)，MySQL生成序列值时将忽略PRIMARYKEY。结果是，该表包含一个单个的序列，而不是符合grp值的序列。
要想以AUTO_INCREMENT值开始而不是1，你可以通过CREATETABLE或ALTERTABLE来设置该值，如下所示:
关于AUTO_INCREMENT的详细信息：
·如何为列指定AUTO_INCREMENT属性：13.1.5节，“CREATETABLE语法”和13.1.2节，“ALTERTABLE语法”。
·AUTO_INCREMENT的动作取决于SQL模式：5.3.2节，“SQL服务器模式”。
·找出含有最新AUTO_INCREMENT值的行：12.1.3节，“比较函数和操作符”。
·设置将用到的AUTO_INCREMENT值:13.5.3节，“SET语法”。
·AUTO_INCREMENT和复制：6.7节，“复制特性和已知问题”.
·AUTO_INCREMENT相关的可用于复制的Server-system变量(auto_increment_increment和auto_increment_offset)：5.3.3节，“服务器系统变量”。
3.7.1.查找所有未分发的孪生项3.7.2.显示孪生对状态的表
这个项目是InstituteofEnvironmentalMedicineatKarolinskaInstitutetStockholm和theSectiononClinicalResearchinAgingandPsychologyattheUniversityofSouthernCalifornia的合作项目。
该项目包括筛选部分，即通过电话回访在瑞典超过65岁的所有孪生。满足某种标准的孪生进入下一阶段。在下一阶段中，医生/护士小组将访问想参加的孪生。部分检查包括物理检查和神经、心理检查、实验室试验、神经成像、心理状况评估和家族历史搜集。并且，应根据医疗和环境风险因素来搜集数据。
可从以下链接找到孪生研究的更多信息：
http://www.mep.ki.se/twinreg/index_en.html
用一个用Perl和MySQL编写的web接口来管理项目的后面部分。
每天晚上所有会谈的数据被移入一个MySQL数据库。
SELECT
CONCAT(p1.id,p1.tvab)+0AStvid,
CONCAT(p1.christian_name,'',p1.surname)ASName,
p1.postal_codeASCode,
p1.cityASCity,
pg.abrevASArea,
IF(td.participation='Aborted','A','')ASA,
p1.deadASdead1,
l.eventASevent1,
td.suspectAStsuspect1,
id.suspectASisuspect1,
td.severeAStsevere1,
id.severeASisevere1,
p2.deadASdead2,
l2.eventASevent2,
h2.nurseASnurse2,
h2.doctorASdoctor2,
td2.suspectAStsuspect2,
id2.suspectASisuspect2,
td2.severeAStsevere2,
id2.severeASisevere2,
l.finish_date
FROM
twin_projectAStp
/*ForTwin1*/
LEFTJOINtwin_dataAStdONtp.id=td.id
ANDtp.tvab=td.tvab
LEFTJOINinformant_dataASidONtp.id=id.id
ANDtp.tvab=id.tvab
LEFTJOINharmonyAShONtp.id=h.id
ANDtp.tvab=h.tvab
LEFTJOINlentusASlONtp.id=l.id
ANDtp.tvab=l.tvab
/*ForTwin2*/
LEFTJOINtwin_dataAStd2ONp2.id=td2.id
ANDp2.tvab=td2.tvab
LEFTJOINinformant_dataASid2ONp2.id=id2.id
ANDp2.tvab=id2.tvab
LEFTJOINharmonyASh2ONp2.id=h2.id
ANDp2.tvab=h2.tvab
LEFTJOINlentusASl2ONp2.id=l2.id
ANDp2.tvab=l2.tvab,
person_dataASp1,
person_dataASp2,
postal_groupsASpg
WHERE
/*p1getsmaintwinandp2getshis/hertwin.*/
/*ptvabisafieldinvertedfromtvab*/
p1.id=tp.idANDp1.tvab=tp.tvabAND
p2.id=p1.idANDp2.ptvab=p1.tvabAND
/*Justthescreeningsurvey*/
tp.survey_no=5AND
/*Skipifpartnerdiedbefore65butallowemigration(dead=9)*/
(p2.dead=0ORp2.dead=9OR
(p2.dead=1AND
(p2.death_date=0OR
(((TO_DAYS(p2.death_date)-TO_DAYS(p2.birthday))/365)
>=65))))
AND
(
/*Twinissuspect*/
(td.future_contact='Yes'ANDtd.suspect=2)OR
/*Twinissuspect-InformantisBlessed*/
(td.future_contact='Yes'ANDtd.suspect=1
ANDid.suspect=1)OR
/*Notwin-InformantisBlessed*/
(ISNULL(td.suspect)ANDid.suspect=1
ANDid.future_contact='Yes')OR
/*Twinbrokenoff-InformantisBlessed*/
(td.participation='Aborted'
ANDid.suspect=1ANDid.future_contact='Yes')OR
/*Twinbrokenoff-Noinform-Havepartner*/
(td.participation='Aborted'ANDISNULL(id.suspect)
ANDp2.dead=0))
AND
l.event='Finished'
/*Getatareacode*/
ANDSUBSTRING(p1.postal_code,1,2)=pg.code
/*Notalreadydistributed*/
AND(h.nurseISNULLORh.nurse=00ORh.doctor=00)
/*Hasnotrefusedorbeenaborted*/
ANDNOT(h.status='Refused'ORh.status='Aborted'
ORh.status='Died'ORh.status='Other')
ORDERBY
tvid;
一些解释：
·CONCAT(p1.id,p1.tvab)+0AStvid
我们想要在id和tvab的连接上以数字顺序排序。结果加0使得MySQL把结果变为一个数字。
·列id
这标识一对孪生。它是所有表中的一个键。
·列tvab
这标识孪生中的一个。它的值为1或2。
·列ptvab
这是tvab的一个逆运算。当tvab是1，它是2，反之亦然。它用来保存输入并且使MySQL的优化查询更容易。
这个查询表明，怎样用联结(p1和p2)从同一个表中查找表。在例子中，这被用来检查孪生的一个是否在65岁前死了。如果如此，行不返回值。
上述所有孪生信息存在于所有表中。我们对id,tvab（所有表）和id,ptvab(person_data)上采用键以使查询更快。
在我们的生产机器上(一台200MHzUltraSPARC)，这个查询返回大约150-200行并且时间不超过一秒。
你可以将以下内容放到Apache配置文件中，更改Apache日志格式，使MySQL更容易读取：
要想将该格式的日志文件装载到MySQL，你可以使用以下语句:
所创建的表中的列应与写入日志文件的LogFormat行对应。
这是MySQL参考手册的翻译版本，关于MySQL参考手册，请访问dev.mysql.com。原始参考手册为英文版，与英文版参考手册相比，本翻译版可能不是最新的。
本章通过演示如何使用mysql客户程序创造和使用一个简单的数据库，提供一个MySQL的入门教程。mysql（有时称为“终端监视器”或只是“监视”）是一个交互式程序，允许你连接一个MySQL服务器，运行查询并察看结果。mysql可以用于批模式：你预先把查询放在一个文件中，然后告诉mysql执行文件的内容。本章将介绍使用mysql的两个方法。
要想查看由mysql提供的选择项目表，可以用--help选项来调用：
shell>mysql--help
本章假定mysql已经被安装在你的机器上，并且有一个MySQL服务器可以连接。否则，请联络MySQL管理员。（如果你是管理员，则需要查阅本手册的其它章节，例如
本章描述建立和使用一个数据库的全过程。如果你仅仅对访问一个已经存在的数据库感兴趣，可以跳过描述怎样创建数据库及它所包含的表的章节。
由于本章是一个教程，省略了许多细节。关于这里所涉及的主题的详细信息，请查阅本手册的相关章节。
3.1.连接与断开服务器
为了连接服务器，当调用mysql时，通常需要提供一个MySQL用户名并且很可能需要一个密码。如果服务器运行在登录服务器之外的其它机器上，还需要指定主机名。联系管理员以找出进行连接所使用的参数(即，连接的主机、用户名和使用的密码)。知道正确的参数后，可以按照以下方式进行连接：shell>mysql-hhost-uuser-p
Enterpassword:********
host和user分别代表MySQL服务器运行的主机名和MySQL账户用户名。设置时替换为正确的值。********代表你的密码；当mysql显示Enterpassword:提示时输入它。
如果有效，你应该看见mysql>提示符后的一些介绍信息：
shell>mysql-hhost-uuser-p
Enterpassword:********
WelcometotheMySQLmonitor.Commandsendwith;or/g.
YourMySQLconnectionidis25338toserverversion:5.1.2-alpha-standard
Type'help;'or'/h'forhelp.Type'/c'toclearthebuffer.
mysql>
mysql>提示符告诉你mysql准备为你输入命令。
一些MySQL安装允许用户以匿名（未命名）用户连接到本地主机上运行的服务器。如果你的机器是这种情况，你应该能不带任何选项地调用mysql与该服务器连接：
shell>mysql
成功地连接后，可以在mysql>提示下输入QUIT(或/q)随时退出：
mysql>QUIT
Bye
在Unix中，也可以按control-D键断开服务器。
在下列章节的大多数例子都假设你连接到了服务器。由mysql>提示指明。
3.2.输入查询
确保你连接上了服务器，如在先前的章节讨论的。连接上服务器并布代表选择了任何数据库，但这样就可以了。知道关于如何查询的基本知识，比马上跳至创建表、给他们装载数据并且从他们检索数据更重要。本节描述输入命令的基本原则，使用几个查询，你能尝试了解mysql是如何工作的。这是一个简单的命令，要求服务器告诉它的版本号和当前日期。在mysql>提示输入如下命令并按回车键：
mysql>SELECTVERSION(),CURRENT_DATE;
+-----------------+--------------+
|VERSION()|CURRENT_DATE|
+-----------------+--------------+
|5.1.2-alpha-log|2005-10-11|
+-----------------+--------------+
1rowinset(0.01sec)
mysql>
这询问说明mysql的几个方面:
·一个命令通常由SQL语句组成，随后跟着一个分号。（有一些例外不需要分号。早先提到的QUIT是一个例子。后面我们将看到其它的例子。）
·当发出一个命令时，mysql将它发送给服务器并显示执行结果，然后显示另一个mysql>显示它准备好接受其它命令。
·mysql用表格(行和列)方式显示查询输出。第一行包含列的标签，随后的行是查询结果。通常，列标签是你取自数据库表的列的名字。如果你正在检索一个表达式而非表列的值(如刚才的例子)，mysql用表达式本身标记列。
·mysql显示返回了多少行，以及查询花了多长时间，它给你提供服务器性能的一个大致概念。因为他们表示时钟时间(不是CPU或机器时间)，并且因为他们受到诸如服务器负载和网络延时的影响，因此这些值是不精确的。（为了简洁，在本章其它例子中不再显示“集合中的行”。）
能够以大小写输入关键词。下列查询是等价的：
mysql>SELECTVERSION(),CURRENT_DATE;
mysql>selectversion(),current_date;
mysql>SeLeCtvErSiOn(),current_DATE;
这是另外一个查询，它说明你能将mysql用作一个简单的计算器：
mysql>SELECTSIN(PI()/4),(4+1)*5;
+------------------+---------+
|SIN(PI()/4)|(4+1)*5|
+------------------+---------+
|0.70710678118655|25|
+------------------+---------+
1rowinset(0.02sec)
至此显示的命令是相当短的单行语句。你可以在一行上输入多条语句，只需要以一个分号间隔开各语句：
mysql>SELECTVERSION();SELECTNOW();
+-----------------+
|VERSION()|
+-----------------+
|5.1.2-alpha-log|
+-----------------+
1rowinset(0.00sec)
+---------------------+
|NOW()|
+---------------------+
|2005-10-1115:15:00|
+---------------------+
1rowinset(0.00sec)
不必全在一个行内给出一个命令，较长命令可以输入到多个行中。mysql通过寻找终止分号而不是输入行的结束来决定语句在哪儿结束。（换句话说，mysql接受自由格式的输入：它收集输入行但直到看见分号才执行。）
这里是一个简单的多行语句的例子：
mysql>SELECT
->USER()
->,
->CURRENT_DATE;
+---------------+--------------+
|USER()|CURRENT_DATE|
+---------------+--------------+
|jon@localhost|2005-10-11|
+---------------+--------------+
在这个例子中，在输入多行查询的第一行后，要注意提示符如何从mysql>变为->，这正是mysql如何指出它没见到完整的语句并且正在等待剩余的部分。提示符是你的朋友，因为它提供有价值的反馈，如果使用该反馈，将总是知道mysql正在等待什么。
如果你决定不想执行正在输入过程中的一个命令，输入/c取消它：
mysql>SELECT
->USER()
->/c
mysql>
这里也要注意提示符，在你输入/c以后，它切换回到mysql>，提供反馈以表明mysql准备接受一个新命令。
下表显示出可以看见的各个提示符并简述它们所表示的mysql的状态：
| 提示符 | 含义 |
| mysql> | 准备好接受新命令。 |
| -> | 等待多行命令的下一行。 |
| '> | 等待下一行，等待以单引号(“'”)开始的字符串的结束。 |
| "> | 等待下一行，等待以双引号(“"”)开始的字符串的结束。 |
| `> | 等待下一行，等待以反斜点(‘`’)开始的识别符的结束。 |
| /*> | 等待下一行，等待以/*开始的注释的结束。 |
mysql>SELECTUSER()
->
如果出现这种情况(你认为输完了语句，但是只有一个->提示符响应)，很可能mysql正在等待分号。如果你没有注意到提示符的提示，在意识到你需要做什么之前，你可能会呆坐一会儿。输入一个分号完成语句，mysql将执行：
mysql>SELECTUSER()
->;
+---------------+
|USER()|
+---------------+
|jon@localhost|
+---------------+
在字符串收集期间将出现'>和">提示符（提示MySQL正等待字符串的结束）。在MySQL中，可以写由‘'’或‘"’字符括起来的字符串(例如，'hello'或"goodbye")，并且mysql允许输入跨越多行的字符串。当看到一个'>或">提示符时，这意味着已经输入了包含以‘'’或‘"’括号字符开始的字符串的一行，但是还没有输入终止字符串的匹配引号。这显示你粗心地省掉了一个引号字符。例如：
mysql>SELECT*FROMmy_tableWHEREname='SmithANDage<30;
'>
如果你输入SELECT语句，然后按Enter（回车）键并等待结果，什么都没有出现。不要惊讶，“为什么该查询这么长呢？”，注意">提示符提供的线索。它告诉你mysql期望见到一个未终止字符串的余下部分。（你看见语句中的错误吗？字符串"Smith丢掉了第二个引号。）
走到这一步，你该做什么？最简单的是取消命令。然而，在这种情况下，你不能只是输入/c，因为mysql作为它正在收集的字符串的一部分来解释它！相反，应输入关闭的引号字符(这样mysql知道你完成了字符串)，然后输入/c：
mysql>SELECT*FROMmy_tableWHEREname='SmithANDage<30;
'>'/c
mysql>
提示符回到mysql>，显示mysql准备好接受一个新命令了。
`>提示符类似于'>和">提示符，但表示你已经开始但没有结束以`>开始的识别符。
知道'>和">提示符的含义很重要，因为如果你错误地输入一个未终止的字符串，任何后面输入的行将要被mysql忽略--包括包含QUIT的行！这可能令人相当困惑，特别是如果取消当前命令前还不知道你需要提供终止引号。
3.3.创建并使用数据库
知道怎样输入命令，便可以访问数据库了。
假定在你的家(你的“动物园”)中有很多宠物，并且你想跟踪关于它们各种类型的信息。你可以通过创建表来保存你的数据并根据所需要的信息装载他们，然后你可以从表中检索数据来回答关于动物不同种类的问题。本节显示如何做到所有这些事情：
·创建数据库
·创建数据库表
·装载数据到数据库表
·以各种方法从表中检索数据
·使用多个表
动物园数据库很简单(特意的)，但是不难把它想象成可能用到类似数据库的真实世界情况。例如，农夫可以使用这样的一个数据库来追踪家畜，或者兽医可以用它跟踪病畜记录。从MySQL网址上可以获得后面章节中将用到的含有部分查询和样例数据的动物园分发。有tar压缩格式(
使用SHOW语句找出服务器上当前存在什么数据库：
mysql>SHOWDATABASES;
+----------+
|Database|
+----------+
|mysql|
|test|
|tmp|
+----------+
可能你的机器上的数据库列表是不同的，但是很可能有mysql和test数据库。mysql是必需的，因为它描述用户访问权限，test数据库经常作为用户试身手的工作区。
请注意如果没有SHOWDATABASES权限，则不能看见所有数据库。参见
如果test数据库存在，尝试访问它：
mysql>USEtest
Databasechanged
注意，USE，类似QUIT，不需要一个分号。（如果你喜欢，你可以用一个分号终止这样的语句；这无碍）USE语句在使用上也有另外一个特殊的地方：它必须在一个单行上给出。
你可列在后面的例子中使用test数据库(如果你能访问它)，但是你在该数据库创建的任何东西可以被访问它的其它人删除，因此，你应该询问MySQL管理员许可你使用自己的一个数据库。假定你想要调用你的menagerie，管理员需要执行这样一条命令：
mysql>GRANTALLONmenagerie.*TO'your_mysql_name'@'your_client_host';
这里your_mysql_name是分配给你的MySQL用户名，your_client_host是所连接的服务器所在的主机。
3.3.1.创建并选择数据库
如果管理员在设置权限时为你创建了数据库，你可以开始使用它。否则，你需要自己创建数据库：mysql>CREATEDATABASEmenagerie;
在Unix下，数据库名称是区分大小写的(不像SQL关键字)，因此你必须总是以menagerie访问数据库，而不能用Menagerie、MENAGERIE或其它一些变量。对表名也是这样的。（在Windows下，该限制不适用，尽管你必须在一个给定的查询中使用同样的大小写来引用数据库和表。但是，由于多种原因，作为最好的惯例，一定要使用与数据库创建时的同样的大小写。）
创建数据库并不表示选定并使用它，你必须明确地操作。为了使menagerie成为当前的数据库，使用这个命令：
mysql>USEmenagerie
Databasechanged
数据库只需要创建一次，但是必须在每次启动mysql会话时在使用前先选择它。你可以根据上面的例子执行一个USE语句来实现。还可以在调用mysql时，通过命令行选择数据库，只需要在提供连接参数之后指定数据库名称。例如：
shell>mysql-hhost-uuser-pmenagerie
Enterpassword:********
注意，刚才显示的命令行中的menagerie不是你的密码。如果你想要在命令行上在-p选项后提供密码，则不能插入空格(例如，如-pmypassword，不是-pmypassword)。但是，不建议在命令行输入密码，因为这样会暴露密码，能被在机器上登录的其它用户窥探到。
3.3.2.创建表
创建数据库是很容易的部分，但是在这时它是空的，正如SHOWTABLES将告诉你的：mysql>SHOWTABLES;
Emptyset(0.00sec)
较难的部分是决定你的数据库结构应该是什么：你需要什么数据库表，各数据库表中有什么样的列。
你将需要一个包含你每个宠物的记录的表。它可称为pet表，并且它应该包含，最少，每个动物的名字。因为名字本身不是很有趣，表应该包含另外的信息。例如，如果在你豢养宠物的家庭有超过一个人，你可能想要列出每个动物的主人。你可能也想要记录例如种类和性别的一些基本的描述信息。
年龄呢？那可能有趣，但是存储到一个数据库中不是一件好事情。年龄随着时间流逝而变化，这意味着你将要不断地更新你的记录。相反,存储一个固定值例如生日比较好，那么，无论何时你需要年龄，可以以当前日期和出生日期之间的差来计算它。MySQL提供了日期运算函数，因此这并不困难。存储出生日期而非年龄还有其它优点：
·你可以使用数据库完成这样的任务，例如生成即将到来的宠物生日的提示。（如果你认为这类查询有点蠢，注意，这与从商务数据库来识别出不久要发给生日祝贺的客户是同一个问题，因为计算机帮助私人联络。）
·你可以相对于日期而不止是当前日期来计算年龄。例如，如果你在数据库存储死亡日期，你能很容易地计算出一只宠物死时有多大。
你可能想到pet表中其它有用的其它类型信息，但是到目前为止这些已经足够了：名字、主人、种类，性别、出生和死亡日期。
使用一个CREATETABLE语句指定你的数据库表的布局：
mysql>CREATETABLEpet(nameVARCHAR(20),ownerVARCHAR(20),
->speciesVARCHAR(20),sexCHAR(1),birthDATE,deathDATE);
VARCHAR适合于name、owner和species列，因为列值是变长的。这些列的长度不必都相同，而且不必是20。你可以挑选从1到65535的任何长度，从中选择一个最合理的值。（如果选择得不合适，后来证明你需要一个更长的字段，MySQL提供一个ALTERTABLE语句。）
可以用多种类型的值来表示动物记录中的性别，例如，"m"和"f"，或"male"和"female"。使用单字符"m"和"f"是最简单的方法。
很显然，birth和death列应选用DATE数据类。
创建了数据库表后，SHOWTABLES应该产生一些输出：
mysql>SHOWTABLES;
+---------------------+
|Tablesinmenagerie|
+---------------------+
|pet|
+---------------------+
为了验证你的表是按你期望的方式创建，使用一个DESCRIBE语句：
mysql>DESCRIBEpet;
+---------+-------------+------+-----+---------+-------+
|Field|Type|Null|Key|Default|Extra|
+---------+-------------+------+-----+---------+-------+
|name|varchar(20)|YES||NULL||
|owner|varchar(20)|YES||NULL||
|species|varchar(20)|YES||NULL||
|sex|char(1)|YES||NULL||
|birth|date|YES||NULL||
|death|date|YES||NULL||
+---------+-------------+------+-----+---------+-------+
你可以随时使用DESCRIBE，例如，如果你忘记表中的列的名称或类型时。
3.3.3.将数据装入表中
创建表后，需要填入内容。通过LOADDATA和INSERT语句可以完成该任务。假定你的宠物纪录描述如下。（假定在MySQL中期望的日期格式是YYYY-MM-DD；这可能与你习惯的不同。）
| name | owner | species | sex | birth | death |
| Fluffy | Harold | cat | f | 1993-02-04 | |
| Claws | Gwen | cat | m | 1994-03-17 | |
| Buffy | Harold | dog | f | 1989-05-13 | |
| Fang | Benny | dog | m | 1990-08-27 | |
| Bowser | Diane | dog | m | 1979-08-31 | 1995-07-29 |
| Chirpy | Gwen | bird | f | 1998-09-11 | |
| Whistler | Gwen | bird | 1997-12-09 | ||
| Slim | Benny | snake | m | 1996-04-29 |
你可以创建一个文本文件“pet.txt”，每行包含一个记录，用定位符(tab)把值分开，并且以CREATETABLE语句中列出的列次序给出。对于丢失的值(例如未知的性别，或仍然活着的动物的死亡日期)，你可以使用NULL值。为了在你的文本文件中表示这些内容，使用/N（反斜线，字母N）。例如，Whistler鸟的记录应为(这里值之间的空白是一个定位符)：
| name | owner | species | sex | birth | death |
| Whistler | Gwen | bird | /N | 1997-12-09 | /N |
mysql>LOADDATALOCALINFILE'/path/pet.txt'INTOTABLEpet;
请注意如果用Windows中的编辑器（使用/r/n做为行的结束符）创建文件，应使用：
mysql>LOADDATALOCALINFILE'/path/pet.txt'INTOTABLEpet
->LINESTERMINATEDBY'/r/n';
（在运行OSX的Apple机上，应使用行结束符'/r'。）
如果你愿意，你能明确地在LOADDATA语句中指出列值的分隔符和行尾标记，但是默认标记是定位符和换行符。这对读入文件“pet.txt”的语句已经足够。
如果该语句失败，可能是你安装的MySQL不与使用默认值的本地文件兼容。关于如何更改请参见
如果想要一次增加一个新记录，可以使用INSERT语句。最简单的形式是，提供每一列的值，其顺序与CREATETABLE语句中列的顺序相同。假定Diane把一只新仓鼠命名为Puffball，你可以使用下面的INSERT语句添加一条新记录：
mysql>INSERTINTOpet
->VALUES('Puffball','Diane','hamster','f','1999-03-30',NULL);注意，这里字符串和日期值均为引号扩起来的字符串。另外，可以直接用INSERT语句插入NULL代表不存在的值。不能使用LOADDATA中所示的的/N。
从这个例子，你应该能看到涉及很多的键入用多个INSERT语句而非单个LOADDATA语句装载你的初始记录。
3.3.4.从表检索信息
SELECT语句用来从数据表中检索信息。语句的一般格式是：
SELECTwhat_to_select
FROMwhich_table
WHEREconditions_to_satisfy;
what_to_select指出你想要看到的内容，可以是列的一个表，或*表示“所有的列”。which_table指出你想要从其检索数据的表。WHERE子句是可选项，如果选择该项，conditions_to_satisfy指定行必须满足的检索条件。
3.3.4.1.选择所有数据
SELECT最简单的形式是从一个表中检索所有记录：mysql>SELECT*FROMpet;
+----------+--------+---------+------+------------+------------+
|name|owner|species|sex|birth|death|
+----------+--------+---------+------+------------+------------+
|Fluffy|Harold|cat|f|1993-02-04|NULL|
|Claws|Gwen|cat|m|1994-03-17|NULL|
|Buffy|Harold|dog|f|1989-05-13|NULL|
|Fang|Benny|dog|m|1990-08-27|NULL|
|Bowser|Diane|dog|m|1979-08-31|1995-07-29|
|Chirpy|Gwen|bird|f|1998-09-11|NULL|
|Whistler|Gwen|bird|NULL|1997-12-09|NULL|
|Slim|Benny|snake|m|1996-04-29|NULL|
|Puffball|Diane|hamster|f|1999-03-30|NULL|
+----------+--------+---------+------+------------+------------+
如果你想要浏览整个表，可以使用这种形式的SELECT，例如，刚刚装载了初始数据集以后。也有可能你想到Bowser的生日看起来不很对。查阅你原来的家谱，你发现正确的出生年是1989，而不是1979。
至少有两种修正方法：
·编辑文件“pet.txt”改正错误，然后使用DELETE和LOADDATA清空并重新装载表:
·mysql>DELETEFROMpet;
·mysql>LOADDATALOCALINFILE'pet.txt'INTOTABLEpet;
然而,如果这样操做，必须重新输入Puffball记录。
·用一个UPDATE语句仅修正错误记录：
·mysql>UPDATEpetSETbirth='1989-08-31'WHEREname='Bowser';
UPDATE只更改有问题的记录，不需要重新装载数据库表。
3.3.4.2.选择特殊行
如上所示，检索整个表是容易的。只需要从SELECT语句中删掉WHERE子句。但是一般你不想看到整个表，特别地当表变得很大时。相反，你通常对回答一个具体的问题更感兴趣，在这种情况下在你想要的信息上进行一些限制。让我们看一些他们回答的有关你宠物的问题的选择查询。可以从表中只选择特定的行。例如，如果你想要验证你对Bowser的生日所做的更改，按下述方法选择Bowser的记录：
mysql>SELECT*FROMpetWHEREname='Bowser';
+--------+-------+---------+------+------------+------------+
|name|owner|species|sex|birth|death|
+--------+-------+---------+------+------------+------------+
|Bowser|Diane|dog|m|1989-08-31|1995-07-29|
+--------+-------+---------+------+------------+------------+
输出证实正确的年份记录为1989，而不是1979。
字符串比较时通常对大小些不敏感，因此你可以将名字指定为"bowser"、"BOWSER"等，查询结果相同。
你可以在任何列上指定条件，不只仅仅是name。例如，如果你想要知道哪个动物在1998以后出生的，测试birth列：
mysql>SELECT*FROMpetWHEREbirth>'1998-1-1';
+----------+-------+---------+------+------------+-------+
|name|owner|species|sex|birth|death|
+----------+-------+---------+------+------------+-------+
|Chirpy|Gwen|bird|f|1998-09-11|NULL|
|Puffball|Diane|hamster|f|1999-03-30|NULL|
+----------+-------+---------+------+------------+-------+
可以组合条件，例如，找出雌性的狗：
mysql>SELECT*FROMpetWHEREspecies='dog'ANDsex='f';
+-------+--------+---------+------+------------+-------+
|name|owner|species|sex|birth|death|
+-------+--------+---------+------+------------+-------+
|Buffy|Harold|dog|f|1989-05-13|NULL|
+-------+--------+---------+------+------------+-------+
上面的查询使用AND逻辑操作符，也有一个OR操作符：
mysql>SELECT*FROMpetWHEREspecies='snake'ORspecies='bird';
+----------+-------+---------+------+------------+-------+
|name|owner|species|sex|birth|death|
+----------+-------+---------+------+------------+-------+
|Chirpy|Gwen|bird|f|1998-09-11|NULL|
|Whistler|Gwen|bird|NULL|1997-12-09|NULL|
|Slim|Benny|snake|m|1996-04-29|NULL|
+----------+-------+---------+------+------------+-------+
AND和OR可以混用，但AND比OR具有更高的优先级。如果你使用两个操作符，使用圆括号指明如何对条件进行分组是一个好主意：
mysql>SELECT*FROMpetWHERE(species='cat'ANDsex='m')
->OR(species='dog'ANDsex='f');
+-------+--------+---------+------+------------+-------+
|name|owner|species|sex|birth|death|
+-------+--------+---------+------+------------+-------+
|Claws|Gwen|cat|m|1994-03-17|NULL|
|Buffy|Harold|dog|f|1989-05-13|NULL|
+-------+--------+---------+------+------------+-------+
3.3.4.3.选择特殊列
如果你不想看到表中的所有行，就命名你感兴趣的列，用逗号分开。例如，如果你想要知道你的动物什么时候出生的，选择name和birth列：mysql>SELECTname,birthFROMpet;
+----------+------------+
|name|birth|
+----------+------------+
|Fluffy|1993-02-04|
|Claws|1994-03-17|
|Buffy|1989-05-13|
|Fang|1990-08-27|
|Bowser|1989-08-31|
|Chirpy|1998-09-11|
|Whistler|1997-12-09|
|Slim|1996-04-29|
|Puffball|1999-03-30|
+----------+------------+
找出谁拥有宠物，使用这个查询：
mysql>SELECTownerFROMpet;
+--------+
|owner|
+--------+
|Harold|
|Gwen|
|Harold|
|Benny|
|Diane|
|Gwen|
|Gwen|
|Benny|
|Diane|
+--------+
请注意该查询只是简单地检索每个记录的owner列，并且他们中的一些出现多次。为了使输出减到最少，增加关键字DISTINCT检索出每个唯一的输出记录：
mysql>SELECTDISTINCTownerFROMpet;
+--------+
|owner|
+--------+
|Benny|
|Diane|
|Gwen|
|Harold|
+--------+
可以使用一个WHERE子句结合行选择与列选择。例如，要想查询狗和猫的出生日期，使用这个查询：
mysql>SELECTname,species,birthFROMpet
->WHEREspecies='dog'ORspecies='cat';
+--------+---------+------------+
|name|species|birth|
+--------+---------+------------+
|Fluffy|cat|1993-02-04|
|Claws|cat|1994-03-17|
|Buffy|dog|1989-05-13|
|Fang|dog|1990-08-27|
|Bowser|dog|1989-08-31|
+--------+---------+------------+
3.3.4.4.分类行
你可能已经注意到前面的例子中结果行没有以特定的顺序显示。然而，当行按某种方式排序时，检查查询输出通常更容易。为了排序结果，使用ORDERBY子句。这里是动物生日，按日期排序：
mysql>SELECTname,birthFROMpetORDERBYbirth;
+----------+------------+
|name|birth|
+----------+------------+
|Buffy|1989-05-13|
|Bowser|1989-08-31|
|Fang|1990-08-27|
|Fluffy|1993-02-04|
|Claws|1994-03-17|
|Slim|1996-04-29|
|Whistler|1997-12-09|
|Chirpy|1998-09-11|
|Puffball|1999-03-30|
+----------+------------+
在字符类型列上，与所有其他比较操作类似，分类功能正常情况下是以区分大小写的方式执行的。这意味着，对于等同但大小写不同的列，并未定义其顺序。对于某一列，可以使用BINARY强制执行区分大小写的分类功能，如：ORDERBYBINARYcol_name.
默认排序是升序，最小的值在第一。要想以降序排序，在你正在排序的列名上增加DESC（降序）关键字：
mysql>SELECTname,birthFROMpetORDERBYbirthDESC;
+----------+------------+
|name|birth|
+----------+------------+
|Puffball|1999-03-30|
|Chirpy|1998-09-11|
|Whistler|1997-12-09|
|Slim|1996-04-29|
|Claws|1994-03-17|
|Fluffy|1993-02-04|
|Fang|1990-08-27|
|Bowser|1989-08-31|
|Buffy|1989-05-13|
+----------+------------+
可以对多个列进行排序，并且可以按不同的方向对不同的列进行排序。例如，按升序对动物的种类进行排序，然后按降序根据生日对各动物种类进行排序（最年轻的动物在最前面），使用下列查询：
mysql>SELECTname,species,birthFROMpet
->ORDERBYspecies,birthDESC;
+----------+---------+------------+
|name|species|birth|
+----------+---------+------------+
|Chirpy|bird|1998-09-11|
|Whistler|bird|1997-12-09|
|Claws|cat|1994-03-17|
|Fluffy|cat|1993-02-04|
|Fang|dog|1990-08-27|
|Bowser|dog|1989-08-31|
|Buffy|dog|1989-05-13|
|Puffball|hamster|1999-03-30|
|Slim|snake|1996-04-29|
+----------+---------+------------+
注意DESC关键字仅适用于在它前面的列名(birth)；不影响species列的排序顺序。
3.3.4.5.日期计算
MySQL提供了几个函数，可以用来计算日期，例如，计算年龄或提取日期部分。要想确定每个宠物有多大，可以计算当前日期的年和出生日期之间的差。如果当前日期的日历年比出生日期早，则减去一年。以下查询显示了每个宠物的出生日期、当前日期和年龄数值的年数字。
mysql>SELECTname,birth,CURDATE(),
->(YEAR(CURDATE())-YEAR(birth))
->-(RIGHT(CURDATE(),5)<RIGHT(birth,5))
->ASage
->FROMpet;
+----------+------------+------------+------+
|name|birth|CURDATE()|age|
+----------+------------+------------+------+
|Fluffy|1993-02-04|2003-08-19|10|
|Claws|1994-03-17|2003-08-19|9|
|Buffy|1989-05-13|2003-08-19|14|
|Fang|1990-08-27|2003-08-19|12|
|Bowser|1989-08-31|2003-08-19|13|
|Chirpy|1998-09-11|2003-08-19|4|
|Whistler|1997-12-09|2003-08-19|5|
|Slim|1996-04-29|2003-08-19|7|
|Puffball|1999-03-30|2003-08-19|4|
+----------+------------+------------+------+
此处，YEAR()提取日期的年部分，RIGHT()提取日期的MM-DD(日历年)部分的最右面5个字符。比较MM-DD值的表达式部分的值一般为1或0，如果CURDATE()的年比birth的年早，则年份应减去1。整个表达式有些难懂，使用alias(age)来使输出的列标记更有意义。
尽管查询可行，如果以某个顺序排列行，则能更容易地浏览结果。添加ORDERBYname子句按照名字对输出进行排序则能够实现。
mysql>SELECTname,birth,CURDATE(),
->(YEAR(CURDATE())-YEAR(birth))
->-(RIGHT(CURDATE(),5)<RIGHT(birth,5))
->ASage
->FROMpetORDERBYname;
+----------+------------+------------+------+
|name|birth|CURDATE()|age|
+----------+------------+------------+------+
|Bowser|1989-08-31|2003-08-19|13|
|Buffy|1989-05-13|2003-08-19|14|
|Chirpy|1998-09-11|2003-08-19|4|
|Claws|1994-03-17|2003-08-19|9|
|Fang|1990-08-27|2003-08-19|12|
|Fluffy|1993-02-04|2003-08-19|10|
|Puffball|1999-03-30|2003-08-19|4|
|Slim|1996-04-29|2003-08-19|7|
|Whistler|1997-12-09|2003-08-19|5|
+----------+------------+------------+------+
为了按age而非name排序输出，只要再使用一个ORDERBY子句：
mysql>SELECTname,birth,CURDATE(),
->(YEAR(CURDATE())-YEAR(birth))
->-(RIGHT(CURDATE(),5)<RIGHT(birth,5))
->ASage
->FROMpetORDERBYage;
+----------+------------+------------+------+
|name|birth|CURDATE()|age|
+----------+------------+------------+------+
|Chirpy|1998-09-11|2003-08-19|4|
|Puffball|1999-03-30|2003-08-19|4|
|Whistler|1997-12-09|2003-08-19|5|
|Slim|1996-04-29|2003-08-19|7|
|Claws|1994-03-17|2003-08-19|9|
|Fluffy|1993-02-04|2003-08-19|10|
|Fang|1990-08-27|2003-08-19|12|
|Bowser|1989-08-31|2003-08-19|13|
|Buffy|1989-05-13|2003-08-19|14|
+----------+------------+------------+------+
可以使用一个类似的查询来确定已经死亡动物的死亡年龄。你通过检查death值是否是NULL来确定是哪些动物，然后，对于那些非NULL值的动物，需要计算出death和birth值之间的差：
mysql>SELECTname,birth,death,
->(YEAR(death)-YEAR(birth))-(RIGHT(death,5)<RIGHT(birth,5))
->ASage
->FROMpetWHEREdeathISNOTNULLORDERBYage;
+--------+------------+------------+------+
|name|birth|death|age|
+--------+------------+------------+------+
|Bowser|1989-08-31|1995-07-29|5|
+--------+------------+------------+------+
查询使用deathISNOTNULL而非death!=NULL，因为NULL是特殊的值，不能使用普通比较符来比较，以后会给出解释。参见
如果你想要知道哪个动物下个月过生日，怎么办？对于这类计算，年和天是无关的，你只需要提取birth列的月份部分。MySQL提供几个日期部分的提取函数，例如YEAR()、MONTH()和DAYOFMONTH()。在这里MONTH()是适合的函数。为了看它怎样工作，运行一个简单的查询，显示birth和MONTH(birth)的值：
mysql>SELECTname,birth,MONTH(birth)FROMpet;
+----------+------------+--------------+
|name|birth|MONTH(birth)|
+----------+------------+--------------+
|Fluffy|1993-02-04|2|
|Claws|1994-03-17|3|
|Buffy|1989-05-13|5|
|Fang|1990-08-27|8|
|Bowser|1989-08-31|8|
|Chirpy|1998-09-11|9|
|Whistler|1997-12-09|12|
|Slim|1996-04-29|4|
|Puffball|1999-03-30|3|
+----------+------------+--------------+
找出下个月生日的动物也是容易的。假定当前月是4月，那么月值是4，你可以找在5月出生的动物(5月)，方法是：
mysql>SELECTname,birthFROMpetWHEREMONTH(birth)=5;
+-------+------------+
|name|birth|
+-------+------------+
|Buffy|1989-05-13|
+-------+------------+
如果当前月份是12月，就有点复杂了。你不能只把1加到月份数(12)上并寻找在13月出生的动物，因为没有这样的月份。相反，你应寻找在1月出生的动物(1月)。
你甚至可以编写查询，不管当前月份是什么它都能工作。采用这种方法不必在查询中使用一个特定的月份，DATE_ADD()允许在一个给定的日期上加上时间间隔。如果在NOW()值上加上一个月，然后用MONTH()提取月份，结果产生生日所在月份：
mysql>SELECTname,birthFROMpet
->WHEREMONTH(birth)=MONTH(DATE_ADD(CURDATE(),INTERVAL1MONTH));
完成该任务的另一个方法是加1以得出当前月份的下一个月(在使用取模函数(MOD)后，如果月份当前值是12，则“回滚”到值0)：
mysql>SELECTname,birthFROMpet
->WHEREMONTH(birth)=MOD(MONTH(CURDATE()),12)+1;
注意，MONTH返回在1和12之间的一个数字，且MOD(something,12)返回在0和11之间的一个数字，因此必须在MOD()以后加1，否则我们将从11月(11)跳到1月(1)。
3.3.4.6.NULL值操作
NULL值可能令人感到奇怪直到你习惯它。概念上，NULL意味着“没有值”或“未知值”，且它被看作与众不同的值。为了测试NULL，你不能使用算术比较操作符例如=、<或!=。为了说明它，试试下列查询：mysql>SELECT1=NULL,1<>NULL,1<NULL,1>NULL;
+----------+-----------+----------+----------+
|1=NULL|1<>NULL|1<NULL|1>NULL|
+----------+-----------+----------+----------+
|NULL|NULL|NULL|NULL|
+----------+-----------+----------+----------+
很显然你不能通过这些比较得到有意义的结果。相反使用ISNULL和ISNOTNULL操作符：
mysql>SELECT1ISNULL,1ISNOTNULL;
+-----------+---------------+
|1ISNULL|1ISNOTNULL|
+-----------+---------------+
|0|1|
+-----------+---------------+
请注意在MySQL中，0或NULL意味着假而其它值意味着真。布尔运算的默认真值是1。
对NULL的特殊处理即是在前面的章节中，为了决定哪个动物不再是活着的，使用deathISNOTNULL而不使用death!=NULL的原因。
在GROUPBY中，两个NULL值视为相同。
执行ORDERBY时，如果运行ORDERBY...ASC，则NULL值出现在最前面，若运行ORDERBY...DESC，则NULL值出现在最后面。
NULL操作的常见错误是不能在定义为NOTNULL的列内插入0或空字符串，但事实并非如此。在NULL表示"没有数值"的地方有数值。使用IS[NOT]NULL则可以很容易地进行测试，如下所示：
mysql>SELECT0ISNULL,0ISNOTNULL,''ISNULL,''ISNOTNULL;
+-----------+---------------+------------+----------------+
|0ISNULL|0ISNOTNULL|''ISNULL|''ISNOTNULL|
+-----------+---------------+------------+----------------+
|0|1|0|1|
+-----------+---------------+------------+----------------+
因此完全可以在定义为NOTNULL的列内插入0或空字符串，实际是NOTNULL。参见
3.3.4.7.模式匹配
MySQL提供标准的SQL模式匹配，以及一种基于象Unix实用程序如vi、grep和sed的扩展正则表达式模式匹配的格式。SQL模式匹配允许你使用“_”匹配任何单个字符，而“%”匹配任意数目字符(包括零字符)。在MySQL中，SQL的模式默认是忽略大小写的。下面给出一些例子。注意使用SQL模式时，不能使用=或!=；而应使用LIKE或NOTLIKE比较操作符。
要想找出以“b”开头的名字：
mysql>SELECT*FROMpetWHEREnameLIKE'b%';
+--------+--------+---------+------+------------+------------+
|name|owner|species|sex|birth|death|
+--------+--------+---------+------+------------+------------+
|Buffy|Harold|dog|f|1989-05-13|NULL|
|Bowser|Diane|dog|m|1989-08-31|1995-07-29|
+--------+--------+---------+------+------------+------------+
要想找出以“fy”结尾的名字：
mysql>SELECT*FROMpetWHEREnameLIKE'%fy';
+--------+--------+---------+------+------------+-------+
|name|owner|species|sex|birth|death|
+--------+--------+---------+------+------------+-------+
|Fluffy|Harold|cat|f|1993-02-04|NULL|
|Buffy|Harold|dog|f|1989-05-13|NULL|
+--------+--------+---------+------+------------+-------+
要想找出包含“w”的名字：
mysql>SELECT*FROMpetWHEREnameLIKE'%w%';
+----------+-------+---------+------+------------+------------+
|name|owner|species|sex|birth|death|
+----------+-------+---------+------+------------+------------+
|Claws|Gwen|cat|m|1994-03-17|NULL|
|Bowser|Diane|dog|m|1989-08-31|1995-07-29|
|Whistler|Gwen|bird|NULL|1997-12-09|NULL|
+----------+-------+---------+------+------------+------------+
要想找出正好包含5个字符的名字，使用“_”模式字符：
mysql>SELECT*FROMpetWHEREnameLIKE'_____';
+-------+--------+---------+------+------------+-------+
|name|owner|species|sex|birth|death|
+-------+--------+---------+------+------------+-------+
|Claws|Gwen|cat|m|1994-03-17|NULL|
|Buffy|Harold|dog|f|1989-05-13|NULL|
+-------+--------+---------+------+------------+-------+
由MySQL提供的模式匹配的其它类型是使用扩展正则表达式。当你对这类模式进行匹配测试时，使用REGEXP和NOTREGEXP操作符(或RLIKE和NOTRLIKE，它们是同义词)。
扩展正则表达式的一些字符是：
·‘.’匹配任何单个的字符。
·字符类“[...]”匹配在方括号内的任何字符。例如，“[abc]”匹配“a”、“b”或“c”。为了命名字符的范围，使用一个“-”。“[a-z]”匹配任何字母，而“[0-9]”匹配任何数字。
·“*”匹配零个或多个在它前面的字符。例如，“x*”匹配任何数量的“x”字符，“[0-9]*”匹配任何数量的数字，而“.*”匹配任何数量的任何字符。
如果REGEXP模式与被测试值的任何地方匹配，模式就匹配(这不同于LIKE模式匹配，只有与整个值匹配，模式才匹配)。
为了定位一个模式以便它必须匹配被测试值的开始或结尾，在模式开始处使用“^”或在模式的结尾用“$”。
为了说明扩展正则表达式如何工作，下面使用REGEXP重写上面所示的LIKE查询：
为了找出以“b”开头的名字，使用“^”匹配名字的开始：
mysql>SELECT*FROMpetWHEREnameREGEXP'^b';
+--------+--------+---------+------+------------+------------+
|name|owner|species|sex|birth|death|
+--------+--------+---------+------+------------+------------+
|Buffy|Harold|dog|f|1989-05-13|NULL|
|Bowser|Diane|dog|m|1989-08-31|1995-07-29|
+--------+--------+---------+------+------------+------------+
如果你想强制使REGEXP比较区分大小写，使用BINARY关键字使其中一个字符串变为二进制字符串。该查询只匹配名称首字母的小写‘b’。
mysql>SELECT*FROMpetWHEREnameREGEXPBINARY'^b';
为了找出以“fy”结尾的名字，使用“$”匹配名字的结尾：
mysql>SELECT*FROMpetWHEREnameREGEXP'fy$';
+--------+--------+---------+------+------------+-------+
|name|owner|species|sex|birth|death|
+--------+--------+---------+------+------------+-------+
|Fluffy|Harold|cat|f|1993-02-04|NULL|
|Buffy|Harold|dog|f|1989-05-13|NULL|
+--------+--------+---------+------+------------+-------+
为了找出包含一个“w”的名字，使用以下查询：
mysql>SELECT*FROMpetWHEREnameREGEXP'w';
+----------+-------+---------+------+------------+------------+
|name|owner|species|sex|birth|death|
+----------+-------+---------+------+------------+------------+
|Claws|Gwen|cat|m|1994-03-17|NULL|
|Bowser|Diane|dog|m|1989-08-31|1995-07-29|
|Whistler|Gwen|bird|NULL|1997-12-09|NULL|
+----------+-------+---------+------+------------+------------+
既然如果一个正则表达式出现在值的任何地方，其模式匹配了，就不必在先前的查询中在模式的两侧放置一个通配符以使得它匹配整个值，就像你使用了一个SQL模式那样。
为了找出包含正好5个字符的名字，使用“^”和“$”匹配名字的开始和结尾，和5个“.”实例在两者之间：
mysql>SELECT*FROMpetWHEREnameREGEXP'^.....$';
+-------+--------+---------+------+------------+-------+
|name|owner|species|sex|birth|death|
+-------+--------+---------+------+------------+-------+
|Claws|Gwen|cat|m|1994-03-17|NULL|
|Buffy|Harold|dog|f|1989-05-13|NULL|
+-------+--------+---------+------+------------+-------+
你也可以使用“{n}”“重复n次”操作符重写前面的查询：
mysql>SELECT*FROMpetWHEREnameREGEXP'^.{5}$';+-------+--------+---------+------+------------+-------+
|name|owner|species|sex|birth|death|
+-------+--------+---------+------+------------+-------+
|Claws|Gwen|cat|m|1994-03-17|NULL|
|Buffy|Harold|dog|f|1989-05-13|NULL|
+-------+--------+---------+------+------------+-------+
3.3.4.8.计数行
数据库经常用于回答这个问题，“某个类型的数据在表中出现的频度?”例如，你可能想要知道你有多少宠物，或每位主人有多少宠物，或你可能想要对你的动物进行各种类型的普查。计算你拥有动物的总数目与“在pet表中有多少行?”是同样的问题，因为每个宠物有一个记录。COUNT(*)函数计算行数，所以计算动物数目的查询应为：
mysql>SELECTCOUNT(*)FROMpet;
+----------+
|COUNT(*)|
+----------+
|9|
+----------+
在前面，你检索了拥有宠物的人的名字。如果你想要知道每个主人有多少宠物，你可以使用COUNT()函数：
mysql>SELECTowner,COUNT(*)FROMpetGROUPBYowner;
+--------+----------+
|owner|COUNT(*)|
+--------+----------+
|Benny|2|
|Diane|2|
|Gwen|3|
|Harold|2|
+--------+----------+
注意，使用GROUPBY对每个owner的所有记录分组，没有它，你会得到错误消息：
mysql>SELECTowner,COUNT(*)FROMpet;
ERROR1140(42000):MixingofGROUPcolumns(MIN(),MAX(),COUNT(),...)
withnoGROUPcolumnsisillegalifthereisnoGROUPBYclause
COUNT()和GROUPBY以各种方式分类你的数据。下列例子显示出进行动物普查操作的不同方式。
每种动物的数量：
mysql>SELECTspecies,COUNT(*)FROMpetGROUPBYspecies;
+---------+----------+
|species|COUNT(*)|
+---------+----------+
|bird|2|
|cat|2|
|dog|3|
|hamster|1|
|snake|1|
+---------+----------+
每种性别的动物数量：
mysql>SELECTsex,COUNT(*)FROMpetGROUPBYsex;
+------+----------+
|sex|COUNT(*)|
+------+----------+
|NULL|1|
|f|4|
|m|4|
+------+----------+
（在这个输出中，NULL表示“未知性别”。）
按种类和性别组合的动物数量：
mysql>SELECTspecies,sex,COUNT(*)FROMpetGROUPBYspecies,sex;
+---------+------+----------+
|species|sex|COUNT(*)|
+---------+------+----------+
|bird|NULL|1|
|bird|f|1|
|cat|f|1|
|cat|m|1|
|dog|f|1|
|dog|m|2|
|hamster|f|1|
|snake|m|1|
+---------+------+----------+
若使用COUNT()，你不必检索整个表。例如,前面的查询，当只对狗和猫进行时，应为：
mysql>SELECTspecies,sex,COUNT(*)FROMpet
->WHEREspecies='dog'ORspecies='cat'
->GROUPBYspecies,sex;
+---------+------+----------+
|species|sex|COUNT(*)|
+---------+------+----------+
|cat|f|1|
|cat|m|1|
|dog|f|1|
|dog|m|2|
+---------+------+----------+
或，如果你仅需要知道已知性别的按性别的动物数目：
mysql>SELECTspecies,sex,COUNT(*)FROMpet
->WHEREsexISNOTNULL
->GROUPBYspecies,sex;
+---------+------+----------+
|species|sex|COUNT(*)|
+---------+------+----------+
|bird|f|1|
|cat|f|1|
|cat|m|1|
|dog|f|1|
|dog|m|2|
|hamster|f|1|
|snake|m|1|
+---------+------+----------+
3.3.4.9.使用1个以上的表
pet表追踪你有哪个宠物。如果你想要记录其它相关信息，例如在他们一生中看兽医或何时后代出生，你需要另外的表。这张表应该像什么呢？需要：·它需要包含宠物名字以便你知道每个事件属于哪个动物。
·需要一个日期以便你知道事件是什么时候发生的。
·需要一个描述事件的字段。
·如果你想要对事件进行分类，则需要一个事件类型字段。
综合上述因素，event表的CREATETABLE语句应为：
mysql>CREATETABLEevent(nameVARCHAR(20),dateDATE,
->typeVARCHAR(15),remarkVARCHAR(255));
对于pet表，最容易的方法是创建包含信息的用定位符分隔的文本文件来装载初始记录：
| name | date | type | remark |
| Fluffy | 1995-05-15 | litter | 4kittens,3female,1male |
| Buffy | 1993-06-23 | litter | 5puppies,2female,3male |
| Buffy | 1994-06-19 | litter | 3puppies,3female |
| Chirpy | 1999-03-21 | vet | neededbeakstraightened |
| Slim | 1997-08-03 | vet | brokenrib |
| Bowser | 1991-10-12 | kennel | |
| Fang | 1991-10-12 | kennel | |
| Fang | 1998-08-28 | birthday | Gavehimanewchewtoy |
| Claws | 1998-03-17 | birthday | Gavehimanewfleacollar |
| Whistler | 1998-12-09 | birthday | Firstbirthday |
mysql>LOADDATALOCALINFILE'event.txt'INTOTABLEevent;
根据你从已经运行在pet表上的查询中学到的，你应该能执行对event表中记录的检索；原理是一样的。但是什么时候event表本身不能回答你可能问的问题呢？
当他们有了一窝小动物时，假定你想要找出每只宠物的年龄。我们前面看到了如何通过两个日期计算年龄。event表中有母亲的生产日期，但是为了计算母亲的年龄，你需要她的出生日期，存储在pet表中。说明查询需要两个表：
mysql>SELECTpet.name,
->(YEAR(date)-YEAR(birth))-(RIGHT(date,5)<RIGHT(birth,5))ASage,
->remark
->FROMpet,event
->WHEREpet.name=event.nameANDevent.type='litter';
+--------+------+-----------------------------+
|name|age|remark|
+--------+------+-----------------------------+
|Fluffy|2|4kittens,3female,1male|
|Buffy|4|5puppies,2female,3male|
|Buffy|5|3puppies,3female|
+--------+------+-----------------------------+
关于该查询要注意的几件事情：
FROM子句列出两个表，因为查询需要从两个表提取信息。
当从多个表组合(联结)信息时，你需要指定一个表中的记录怎样能匹配其它表的记录。这很简单，因为它们都有一个name列。查询使用WHERE子句基于name值来匹配2个表中的记录。
因为name列出现在两个表中，当引用列时，你一定要指定哪个表。把表名附在列名前即可以实现。
你不必有2个不同的表来进行联结。如果你想要将一个表的记录与同一个表的其它记录进行比较，可以将一个表联结到自身。例如，为了在你的宠物之中繁殖配偶，你可以用pet联结自身来进行相似种类的雄雌配对：
mysql>SELECTp1.name,p1.sex,p2.name,p2.sex,p1.species
->FROMpetASp1,petASp2
->WHEREp1.species=p2.speciesANDp1.sex='f'ANDp2.sex='m';
+--------+------+--------+------+---------+
|name|sex|name|sex|species|
+--------+------+--------+------+---------+
|Fluffy|f|Claws|m|cat|
|Buffy|f|Fang|m|dog|
|Buffy|f|Bowser|m|dog|
+--------+------+--------+------+---------+
在这个查询中，我们为表名指定别名以便能引用列并且使得每一个列引用与哪个表实例相关联更直观。
3.4.获得数据库和表的信息
如果你忘记数据库或表的名字，或给定的表的结构是什么(例如，它的列叫什么)，怎么办？MySQL通过提供数据库及其支持的表的信息的几个语句解决这个问题。你已经见到了SHOWDATABASES，它列出由服务器管理的数据库。为了找出当前选择了哪个数据库，使用DATABASE()函数：
mysql>SELECTDATABASE();
+------------+
|DATABASE()|
+------------+
|menagerie|
+------------+
如果你还没选择任何数据库，结果是NULL。
为了找出当前的数据库包含什么表(例如，当你不能确定一个表的名字)，使用这个命令：
mysql>SHOWTABLES;
+---------------------+
|Tablesinmenagerie|
+---------------------+
|event|
|pet|
+---------------------+
如果你想要知道一个表的结构，可以使用DESCRIBE命令；它显示表中每个列的信息：
mysql>DESCRIBEpet;
+---------+-------------+------+-----+---------+-------+
|Field|Type|Null|Key|Default|Extra|
+---------+-------------+------+-----+---------+-------+
|name|varchar(20)|YES||NULL||
|owner|varchar(20)|YES||NULL||
|species|varchar(20)|YES||NULL||
|sex|char(1)|YES||NULL||
|birth|date|YES||NULL||
|death|date|YES||NULL||
+---------+-------------+------+-----+---------+-------+
Field显示列名字，Type是列的数据类型，Null表示列是否能包含NULL值，Key显示列是否被索引而Default指定列的默认值。
如果表有索引，SHOWINDEXFROMtbl_name生成有关索引的信息。
3.5.在批处理模式下使用mysql
在前面的章节中，你交互式地使用mysql输入查询并且查看结果。你也可以以批模式运行mysql。为了做到这些，把你想要运行的命令放在一个文件中，然后告诉mysql从文件读取它的输入：shell>mysql<batch-file
如果在Windows下运行mysql，并且文件中有一些可以造成问题的特殊字符，可以这样操作：
C:/>mysql-e"sourcebatch-file"
如果你需要在命令行上指定连接参数，命令应为：
shell>mysql-hhost-uuser-p<batch-file
Enterpassword:********
当这样操作mysql时，则创建一个脚本文件，然后执行脚本。
如果你想在语句出现错误的时候仍想继续执行脚本，则应使用--force命令行选项。
为什么要使用一个脚本？有很多原因：
如果你需要重复运行查询(比如说，每天或每周)，可以把它编成一个脚本，则每次执行时不必重新键入。
可以通过拷贝并编辑脚本文件从类似的现有的查询生成一个新查询。
当你正在开发查询时，批模式也是很有用的，特别对多行命令或多语句命令序列。如果你犯了一个错误，你不必重新输入所有内容，只需要编辑脚本来改正错误，然后告诉mysql再次执行脚本。
如果你有一个产生多个输出的查询，你可以通过一个分页器而不是盯着它翻屏到屏幕的顶端来运行输出：
·shell>mysql<batch-file|more
你可以捕捉文件中的输出以便进行进一步的处理：
·shell>mysql<batch-file>mysql.out
你可以将脚本分发给另外的人，以便他们也能运行命令。
某些情况不允许交互地使用，例如,当你从一个cron任务中运行查询时。在这种情况下，你必须使用批模式。
当你以批模式运行mysql时，比起你交互地使用它时，其默认输出格式是不同的(更简明些)。例如，当交互式运行SELECTDISTINCTspeciesFROMpet时，输出应为：
+---------+
|species|
+---------+
|bird|
|cat|
|dog|
|hamster|
|snake|
+---------+
但是当以批模式运行时，输出应为：
species
bird
cat
dog
hamster
snake
如果你想要在批模式中得到交互输出格式，使用mysql-t。为了回显以输出被执行的命令，使用mysql-vvv。
你还可以使用源代码或/.命令从mysql提示符运行脚本：
mysql>sourcefilename;
mysql>/.filename
3.6.常用查询的例子
下面是一些学习如何用MySQL解决一些常见问题的例子。
在一些例子中，使用数据库表“shop”来储存某个商人（经销商）的每件物品(物品号)的价格。假定每个商人对每项物品有一个固定价格，那么(物品，商人)即为该记录的主关键字。
启动命令行工具mysql并选择数据库：
shell>mysqlyour-database-name
（在大多数MySQL中，你可以使用test数据库）。
你可以使用以下语句创建示例表：
mysql>CREATETABLEshop(
->articleINT(4)UNSIGNEDZEROFILLDEFAULT'0000'NOTNULL,
->dealerCHAR(20)DEFAULT''NOTNULL,
->priceDOUBLE(16,2)DEFAULT'0.00'NOTNULL,
->PRIMARYKEY(article,dealer));
mysql>INSERTINTOshopVALUES
->(1,'A',3.45),(1,'B',3.99),(2,'A',10.99),(3,'B',1.45),
->(3,'C',1.69),(3,'D',1.25),(4,'D',19.95);
执行语句后，表应包含以下内容：
mysql>SELECT*FROMshop;
+---------+--------+-------+
|article|dealer|price|
+---------+--------+-------+
|0001|A|3.45|
|0001|B|3.99|
|0002|A|10.99|
|0003|B|1.45|
|0003|C|1.69|
|0003|D|1.25|
|0004|D|19.95|
+---------+--------+-------+
3.6.1.列的最大值
“最大的物品号是什么？”+---------+
|article|
+---------+
|4|
+---------+
3.6.2.拥有某个列的最大值的行
任务：找出最贵物品的编号、销售商和价格。这很容易用一个子查询做到：
SELECTarticle,dealer,price
FROMshop
WHEREprice=(SELECTMAX(price)FROMshop);
另一个解决方案是按价格降序排序所有行并用MySQL特定LIMIT子句只得到第一行：
SELECTarticle,dealer,price
FROMshop
ORDERBYpriceDESC
LIMIT1;
注:如果有多项最贵的物品(例如每个的价格为19.95)，LIMIT解决方案仅仅显示其中一个！
3.6.3.列的最大值：按组
任务：每项物品的的最高价格是多少？FROMshop
GROUPBYarticle
+---------+-------+
|article|price|
+---------+-------+
|0001|3.99|
|0002|10.99|
|0003|1.69|
|0004|19.95|
+---------+-------+
3.6.4.拥有某个字段的组间最大值的行
任务：对每项物品，找出最贵价格的物品的经销商。可以用这样一个子查询解决该问题：
FROMshops1
WHEREprice=(SELECTMAX(s2.price)
FROMshops2
WHEREs1.article=s2.article);
3.6.5.使用用户变量
你可以清空MySQL用户变量以记录结果，不必将它们保存到客户端的临时变量中。（参见例如，要找出价格最高或最低的物品的，其方法是：
mysql>SELECT*FROMshopWHEREprice=@min_priceORprice=@max_price;
+---------+--------+-------+
|article|dealer|price|
+---------+--------+-------+
|0003|D|1.25|
|0004|D|19.95|
+---------+--------+-------+
3.6.6.使用外键
在MySQL中，InnoDB表支持对外部关键字约束条件的检查。参见只是联接两个表时，不需要外部关键字。对于除InnoDB类型的表，当使用REFERENCEStbl_name(col_name)子句定义列时可以使用外部关键字，该子句没有实际的效果，只作为备忘录或注释来提醒，你目前正定义的列指向另一个表中的一个列。执行该语句时，实现下面很重要：
·MySQL不执行表tbl_name中的动作，例如作为你正定义的表中的行的动作的响应而删除行；换句话说，该句法不会致使ONDELETE或ONUPDATE行为（如果你在REFERENCES子句中写入ONDELETE或ONUPDATE子句，将被忽略）。
·该句法可以创建一个column；但不创建任何索引或关键字。
·如果用该句法定义InnoDB表，将会导致错误。
你可以使用作为联接列创建的列，如下所示：
CREATETABLEperson(
idSMALLINTUNSIGNEDNOTNULLAUTO_INCREMENT,
nameCHAR(60)NOTNULL,
PRIMARYKEY(id)
);
CREATETABLEshirt(
idSMALLINTUNSIGNEDNOTNULLAUTO_INCREMENT,
styleENUM('t-shirt','polo','dress')NOTNULL,colorENUM('red','blue','orange','white','black')NOTNULL,ownerSMALLINTUNSIGNEDNOTNULLREFERENCESperson(id),
PRIMARYKEY(id)
);
INSERTINTOpersonVALUES(NULL,'AntonioPaz');
SELECT@last:=LAST_INSERT_ID();
INSERTINTOshirtVALUES
(NULL,'polo','blue',@last),
(NULL,'dress','white',@last),
(NULL,'t-shirt','blue',@last);
INSERTINTOpersonVALUES(NULL,'LillianaAngelovska');
SELECT@last:=LAST_INSERT_ID();
INSERTINTOshirtVALUES
(NULL,'dress','orange',@last),
(NULL,'polo','red',@last),
(NULL,'dress','blue',@last),
(NULL,'t-shirt','white',@last);
SELECT*FROMperson;
+----+---------------------+
|id|name|
+----+---------------------+
|1|AntonioPaz|
|2|LillianaAngelovska|
+----+---------------------+
SELECT*FROMshirt;
+----+---------+--------+-------+
|id|style|color|owner|
+----+---------+--------+-------+
|1|polo|blue|1|
|2|dress|white|1|
|3|t-shirt|blue|1|
|4|dress|orange|2|
|5|polo|red|2|
|6|dress|blue|2|
|7|t-shirt|white|2|
+----+---------+--------+-------+
SELECTs.*FROMpersonp,shirts
WHEREp.nameLIKE'Lilliana%'
ANDs.owner=p.id
ANDs.color<>'white';
+----+-------+--------+-------+
|id|style|color|owner|
+----+-------+--------+-------+
|4|dress|orange|2|
|5|polo|red|2|
|6|dress|blue|2|
+----+-------+--------+-------+
按照这种方式使用，REFERENCES子句不会显示在SHOWCREATETABLE或DESCRIBE的输出中:
SHOWCREATETABLEshirt/G
***************************1.row***************************
Table:shirt
CreateTable:CREATETABLE`shirt`(
`id`smallint(5)unsignedNOTNULLauto_increment,
`style`enum('t-shirt','polo','dress')NOTNULL,`color`enum('red','blue','orange','white','black')NOTNULL,`owner`smallint(5)unsignedNOTNULL,
PRIMARYKEY(`id`)
)ENGINE=MyISAMDEFAULTCHARSET=latin1
在列定义中，按这种方式使用REFERENCES作为注释或“提示”适用于表MyISAM和BerkeleyDB。
3.6.7.根据两个键搜索
可以充分利用使用单关键字的OR子句，如同AND的处理。一个比较灵活的例子是寻找两个通过OR组合到一起的关键字：
SELECTfield1_index,field2_indexFROMtest_table
WHEREfield1_index='1'ORfield2_index='1'
该情形是已经优化过的。参见
还可以使用UNION将两个单独的SELECT语句的输出合成到一起来更有效地解决该问题。参见
”。
每个SELECT只搜索一个关键字，可以进行优化：
SELECTfield1_index,field2_index
FROMtest_tableWHEREfield1_index='1'
UNION
SELECTfield1_index,field2_index
FROMtest_tableWHEREfield2_index='1';
3.6.8.根据天计算访问量
下面的例子显示了如何使用位组函数来计算每个月中用户访问网页的天数。CREATETABLEt1(yearYEAR(4),monthINT(2)UNSIGNEDZEROFILL,
dayINT(2)UNSIGNEDZEROFILL);
INSERTINTOt1VALUES(2000,1,1),(2000,1,20),(2000,1,30),(2000,2,2),
(2000,2,23),(2000,2,23);
示例表中含有代表用户访问网页的年－月－日值。可以使用以下查询来确定每个月的访问天数：
SELECTyear,month,BIT_COUNT(BIT_OR(1<<day))ASdaysFROMt1
GROUPBYyear,month;
将返回：
+------+-------+------+
|year|month|days|
+------+-------+------+
|2000|01|3|
|2000|02|2|
+------+-------+------+
该查询计算了在表中按年/月组合的不同天数，可以自动去除重复的询问。
3.6.9.使用AUTO_INCREMENT
可以通过AUTO_INCREMENT属性为新的行产生唯一的标识：CREATETABLEanimals(
idMEDIUMINTNOTNULLAUTO_INCREMENT,
nameCHAR(30)NOTNULL,
PRIMARYKEY(id)
);
INSERTINTOanimals(name)VALUES
('dog'),('cat'),('penguin'),('lax'),('whale'),('ostrich');SELECT*FROManimals;
将返回：
+----+---------+
|id|name|
+----+---------+
|1|dog|
|2|cat|
|3|penguin|
|4|lax|
|5|whale|
|6|ostrich|
+----+---------+
你可以使用LAST_INSERT_ID()SQL函数或mysql_insert_id()CAPI函数来查询最新的AUTO_INCREMENT值。这些函数与具体连接有关，因此其返回值不会被其它执行插入功能的连接影响。
注释：对于多行插入，LAST_INSERT_ID()和mysql_insert_id()从插入的第一行实际返回AUTO_INCREMENT关键字。在复制设置中，通过该函数可以在其它服务器上正确复制多行插入。
对于MyISAM和BDB表，你可以在第二栏指定AUTO_INCREMENT以及多列索引。此时，AUTO_INCREMENT列生成的值的计算方法为：MAX(auto_increment_column)+1WHEREprefix=given-prefix。如果想要将数据放入到排序的组中可以使用该方法。
CREATETABLEanimals(
grpENUM('fish','mammal','bird')NOTNULL,idMEDIUMINTNOTNULLAUTO_INCREMENT,
nameCHAR(30)NOTNULL,
PRIMARYKEY(grp,id)
);
INSERTINTOanimals(grp,name)VALUES
('mammal','dog'),('mammal','cat'),('bird','penguin'),('fish','lax'),('mammal','whale'),('bird','ostrich');SELECT*FROManimalsORDERBYgrp,id;
将返回：
+--------+----+---------+
|grp|id|name|
+--------+----+---------+
|fish|1|lax|
|mammal|1|dog|
|mammal|2|cat|
|mammal|3|whale|
|bird|1|penguin|
|bird|2|ostrich|
+--------+----+---------+
请注意在这种情况下（AUTO_INCREMENT列是多列索引的一部分），如果你在任何组中删除有最大AUTO_INCREMENT值的行，将会重新用到AUTO_INCREMENT值。对于MyISAM表也如此,对于该表一般不重复使用AUTO_INCREMENT值。
如果AUTO_INCREMENT列是多索引的一部分，MySQL将使用该索引生成以AUTO_INCREMENT列开始的序列值。。例如，如果animals表含有索引PRIMARYKEY(grp,id)和INDEX(id)，MySQL生成序列值时将忽略PRIMARYKEY。结果是，该表包含一个单个的序列，而不是符合grp值的序列。
要想以AUTO_INCREMENT值开始而不是1，你可以通过CREATETABLE或ALTERTABLE来设置该值，如下所示:
mysql>ALTERTABLEtblAUTO_INCREMENT=100;
关于AUTO_INCREMENT的详细信息：
·如何为列指定AUTO_INCREMENT属性：
·AUTO_INCREMENT的动作取决于SQL模式：
·找出含有最新AUTO_INCREMENT值的行：
·设置将用到的AUTO_INCREMENT值:
·AUTO_INCREMENT和复制：
·AUTO_INCREMENT相关的可用于复制的Server-system变量(auto_increment_increment和auto_increment_offset)：
3.7.孪生项目的查询
这个项目是InstituteofEnvironmentalMedicineatKarolinskaInstitutetStockholm和theSectiononClinicalResearchinAgingandPsychologyattheUniversityofSouthernCalifornia的合作项目。
该项目包括筛选部分，即通过电话回访在瑞典超过65岁的所有孪生。满足某种标准的孪生进入下一阶段。在下一阶段中，医生/护士小组将访问想参加的孪生。部分检查包括物理检查和神经、心理检查、实验室试验、神经成像、心理状况评估和家族历史搜集。并且，应根据医疗和环境风险因素来搜集数据。
可从以下链接找到孪生研究的更多信息：
用一个用Perl和MySQL编写的web接口来管理项目的后面部分。
每天晚上所有会谈的数据被移入一个MySQL数据库。
3.7.1.查找所有未分发的孪生项
下列查询用来决定谁进入项目的第二部分：CONCAT(p1.id,p1.tvab)+0AStvid,
CONCAT(p1.christian_name,'',p1.surname)ASName,
p1.postal_codeASCode,
p1.cityASCity,
pg.abrevASArea,
IF(td.participation='Aborted','A','')ASA,
p1.deadASdead1,
l.eventASevent1,
td.suspectAStsuspect1,
id.suspectASisuspect1,
td.severeAStsevere1,
id.severeASisevere1,
p2.deadASdead2,
l2.eventASevent2,
h2.nurseASnurse2,
h2.doctorASdoctor2,
td2.suspectAStsuspect2,
id2.suspectASisuspect2,
td2.severeAStsevere2,
id2.severeASisevere2,
l.finish_date
FROM
twin_projectAStp
/*ForTwin1*/
LEFTJOINtwin_dataAStdONtp.id=td.id
ANDtp.tvab=td.tvab
LEFTJOINinformant_dataASidONtp.id=id.id
ANDtp.tvab=id.tvab
LEFTJOINharmonyAShONtp.id=h.id
ANDtp.tvab=h.tvab
LEFTJOINlentusASlONtp.id=l.id
ANDtp.tvab=l.tvab
/*ForTwin2*/
LEFTJOINtwin_dataAStd2ONp2.id=td2.id
ANDp2.tvab=td2.tvab
LEFTJOINinformant_dataASid2ONp2.id=id2.id
ANDp2.tvab=id2.tvab
LEFTJOINharmonyASh2ONp2.id=h2.id
ANDp2.tvab=h2.tvab
LEFTJOINlentusASl2ONp2.id=l2.id
ANDp2.tvab=l2.tvab,
person_dataASp1,
person_dataASp2,
postal_groupsASpg
WHERE
/*p1getsmaintwinandp2getshis/hertwin.*/
/*ptvabisafieldinvertedfromtvab*/
p1.id=tp.idANDp1.tvab=tp.tvabAND
p2.id=p1.idANDp2.ptvab=p1.tvabAND
/*Justthescreeningsurvey*/
tp.survey_no=5AND
/*Skipifpartnerdiedbefore65butallowemigration(dead=9)*/
(p2.dead=0ORp2.dead=9OR
(p2.dead=1AND
(p2.death_date=0OR
(((TO_DAYS(p2.death_date)-TO_DAYS(p2.birthday))/365)
>=65))))
AND
(
/*Twinissuspect*/
(td.future_contact='Yes'ANDtd.suspect=2)OR
/*Twinissuspect-InformantisBlessed*/
(td.future_contact='Yes'ANDtd.suspect=1
ANDid.suspect=1)OR
/*Notwin-InformantisBlessed*/
(ISNULL(td.suspect)ANDid.suspect=1
ANDid.future_contact='Yes')OR
/*Twinbrokenoff-InformantisBlessed*/
(td.participation='Aborted'
ANDid.suspect=1ANDid.future_contact='Yes')OR
/*Twinbrokenoff-Noinform-Havepartner*/
(td.participation='Aborted'ANDISNULL(id.suspect)
ANDp2.dead=0))
AND
l.event='Finished'
/*Getatareacode*/
ANDSUBSTRING(p1.postal_code,1,2)=pg.code
/*Notalreadydistributed*/
AND(h.nurseISNULLORh.nurse=00ORh.doctor=00)
/*Hasnotrefusedorbeenaborted*/
ANDNOT(h.status='Refused'ORh.status='Aborted'
ORh.status='Died'ORh.status='Other')
ORDERBY
tvid;
一些解释：
·CONCAT(p1.id,p1.tvab)+0AStvid
我们想要在id和tvab的连接上以数字顺序排序。结果加0使得MySQL把结果变为一个数字。
·列id
这标识一对孪生。它是所有表中的一个键。
·列tvab
这标识孪生中的一个。它的值为1或2。
·列ptvab
这是tvab的一个逆运算。当tvab是1，它是2，反之亦然。它用来保存输入并且使MySQL的优化查询更容易。
这个查询表明，怎样用联结(p1和p2)从同一个表中查找表。在例子中，这被用来检查孪生的一个是否在65岁前死了。如果如此，行不返回值。
上述所有孪生信息存在于所有表中。我们对id,tvab（所有表）和id,ptvab(person_data)上采用键以使查询更快。
在我们的生产机器上(一台200MHzUltraSPARC)，这个查询返回大约150-200行并且时间不超过一秒。
| 表 | 行数 |
| person_data | 71074 |
| lentus | 5291 |
| twin_project | 5286 |
| twin_data | 2012 |
| informant_data | 663 |
| harmony | 381 |
| postal_groups | 100 |
3.7.2.显示孪生对状态的表
每一次会面以一个称为event的状态码结束。下面显示的查询被用来显示按事件组合的所有孪生的表。这表明多少对孪生已经完成，多少对的其中之一已完成而另一个拒绝了，等等。SELECT
t1.event,
t2.event,
COUNT(*)
FROM
lentusASt1,
lentusASt2,
twin_projectAStp
WHERE
/*Wearelookingatonepairatatime*/
t1.id=tp.id
ANDt1.tvab=tp.tvab
ANDt1.id=t2.id
/*Justthescreeningsurvey*/
ANDtp.survey_no=5
/*Thismakeseachpaironlyappearonce*/
ANDt1.tvab='1'ANDt2.tvab='2'
GROUPBY
t1.event,t2.event;
3.8.与Apache一起使用MySQL
还有一些项目，你可以从MySQL数据库鉴别用户，并且你还可以将日志文件写入MySQL数据库表。你可以将以下内容放到Apache配置文件中，更改Apache日志格式，使MySQL更容易读取：
LogFormat/
"/"%h/",%{%Y%m%d%H%M%S}t,%>s,/"%b/",/"%{Content-Type}o/",//"%U/",/"%{Referer}i/",/"%{User-Agent}i/""要想将该格式的日志文件装载到MySQL，你可以使用以下语句:
LOADDATAINFILE'/local/access_log'INTOTABLEtbl_name
FIELDSTERMINATEDBY','OPTIONALLYENCLOSEDBY'"'ESCAPEDBY'//'
所创建的表中的列应与写入日志文件的LogFormat行对应。
这是MySQL参考手册的翻译版本，关于MySQL参考手册，请访问
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- mysql 基本使用教程(源于网络)
- mysql 基本使用教程(源于网络)
- mysql 基本使用教程(源于网络)
- mysql 基本使用教程(源于网络)
- MySQL中InnoDB存储引擎的锁的基本使用教程
- 在MySQL中使用子查询和标量子查询的基本操作教程
- MySQL中join语句的基本使用教程及其字段对性能的影响
- MySQL中使用表别名与字段别名的基本教程
- MySQL中临时表的基本创建与使用教程
- MySQL中几种数据统计查询的基本使用教程
- MySQL中临时表的基本创建与使用教程（CREATETEMPORARY TABLE）
- MySQL中临时表的基本创建与使用教程
- MySQL中使用表别名与字段别名的基本教程
- MySQL中Distinct和Group By语句的基本使用教程
- MySQL中InnoDB存储引擎的锁的基本使用教程
- MySQL中临时表的基本创建与使用教程
- MySQL中几种数据统计查询的基本使用教程
- 超详细MySQL安装及基本使用教程
- 安装和使用percona-toolkit来辅助操作MySQL的基本教程