SQL 必知必会（第3版）

当前位置:首页 > 网络编程 > 数据库 > SQL 必知必会（第3版）

出版社:人民邮电出版社
出版日期:2007-07-01
ISBN:9787115162601
作者:(英)Ben Forta
页数:204页

内容概要

Ben Forta是世界知名的技术作家，也是Adobe技术界最为知名的专家之一，目前担任Adobe公司的高级技术推广专家。他具有计算机行业20多年工作经验，多年来撰写了十几本技术图书，其中不少是世界畅销书，已被翻译为十几种文字。除本书外，他撰写的《正则表达式必知必会》也即将由人民邮电出版社出版。读者可以通过他的个人网站http://www.forta.com了解更多信息。

书籍目录

第1章　了解SQL

第2章　检索数据

第3章　排序检索数据

第4章　过滤数据

第5章　高级数据过滤

第6章　用通配符进行过滤

第7章　创建计算字段

第8章　使用数据处理函数

第9章　汇总数据

第10章　分组数据

第11章　使用子查询

第12章　联结表

第13章　创建高级联结

第14章　组合查询

第15章　插入数据

第16章　更新和删除数据

第17章　创建和操纵表

第18章　使用视图

第19章　使用存储过程

第20章　管理事务处理

第21章　使用游标

第22章　了解高级SQL特性

附录A　样例表脚本

附录B　流行的应用系统

附录C　SQL语句的语法

附录D　SQL数据类型

附录E　SQL保留字

索引

编辑推荐

　　《SQL必知必会》(第3版)注重实用性，操作性很强，适合于SQL的初学者学习和广大软件开发及管理人员参考。

作者简介

SQL 是目前使用最为广泛的数据库语言之一。本书没有涉及理论，而是从实践出发，由浅入深地讲解了广大读者所必需的SQL 知识，适用于各种主流数据库。实例丰富，便于查阅。本书涉及不同平台上数据的排序、过滤和分组，以及表、视图、联结、子查询、游标、存储过程和触发器等内容，通过本书读者可以系统地学习到SQL 的知识和方法。

本书注重实用性，操作性很强，适合于SQL 的初学者学习和广大软件开发及管理人员参考。

图书封面

SQL 必知必会（第3版）下载精选章节试读更多精彩书评

发布书评

精彩书评 (总计12条)

记得是从候清荣那里借阅的，通过这本书可以轻松全面地掌握最常用的SQL，配套了示例脚本可以练习。通过本书可以快速入门。对我第一次找工作起了很大的作用。到甲方做项目经理三年了，别说程序，现在sql都写得很少了，准备再邮购一本，抽空温习一下。
《SQL必知必会(第3版)》刚买来的时候就非常惊讶--居然这一200页不到的小本本定的市场价是29元，32开的handbook可方便随身带，买来后一口气就阅读到了第七章，大呼过瘾。里面的内容是以前知道但没有理解，但没有像这本书这么教得通俗易懂的，如形容数据表就像是一个文件夹，数据库实例就像是一个文件柜这样容易理解。这本书的原作者写得不错，翻译的水平也极佳。这本书的定位是入门，所以一切都以点到就为止了。比如存储过程那一章原作者就说了只以简单的讲一讲。我们平时实际工作中写得就复杂多了。而且原作者把各种主流DBMS的区别与一般常见的实践技巧全部传授给了你，我们这样的 SQL 菜鸟不正需要这些知识吗？
内容很多，很充实。比起之前看的SQL基础教程，书更薄，但是有关SQL的内容反而还多优点就不用说了，书薄，翻起来很快，而且适合没事翻翻，技术类的书做到这么薄可不常见缺点呢，就是例子太少，排版太密，影响阅读的心情。不过这本书要是例子很多，内容很具体的话，就不是SQL必知必会了~

精彩短评 (总计67条)

　　很棒的书。
　　老外的书总是那么有条理，由深入浅。你越看越想看。虽然后面的速度会慢些，内容难度有所提高。但是看下来后你会有对SQL的增删改查足矣。
　　这是一本基础的书，不是sql基础理论，而是一些常见应用的知识讲解。
　　值得一读。
　　讲的“浅”，但是知识很实用很基本的知识，也是使用中需要掌握的。由于现在的数据库都有自己的方言，所以结合数据管理器的使用方法是另一说。你需要看其他的书来了解。但是基础知识是通用的。
基础的教程，简单而又充实
很基础的数据库内容，不过条理结构清晰，让大家对SQL有个整体全面的认识。
样例表怎么下载？
入门，或者长时间不用快速回忆用不错
看新版，有增加的内容。
先入个门
很不错的参考书，入门级别。复习了一遍SQL。
简短，重点讲的是SQL语句，数据库部分需要另补。如果是零基础，可能还需要查一查相关术语，先补点数据库之类的知识。
太浅了，一口气可读完
没有废话，直接上
　　对于行家来说，这应该是本非常非常基础的书，但是这本书的目的也就是让菜鸟能够入门。知道那些数据库的常用操作以及概念...通读全书基本不累，理论上周末两天就可以解决...话说本人不才，毕业N年从未学习过数据库，现在算是了解了数据库的基本操作语法，以及相关术语的出处，接下来对于那些数据库操作的玩意儿应该有底了
　　最后，说句受益匪浅
入门既简单很快看完
总算是在15年最后一天看完，温故而知新~比较全面的介绍，有条理且清晰。
理论性的入门挺好的，由浅入深以及搭配使用，各个层级捋得比较清晰。实践的话要看是具体哪个数据库，再具体练一练才好
　　总体来说这是一本非常基础的数据库方面的书。这本书几乎涉及了SQL的全部内容。涉及的都不深入，比如存储过程、事务处理、约束、游标这些高级内容就只是一笔带过，作为一本初级入门书能够大致了解一下高级主题为进一步深入了解做准备。
　　在基础语法方面做得很优秀。SELECT查询语句由浅入深讲得很容易理解。由最简单的检索单个列，检索多列，排序，WHERE子句过滤行到计算字段，使用函数以及汇总查询和联结多表查询。这些方面讲得透彻。
　　比如，汇总查询时，会提醒WHERE子句应位于GROUP BY子句之前，并且出现在SELECT后面的列名，要么是汇总字段，要么是GROUP BY子句的列名。
　　不足之处是在插入和删除讲得简略，似乎作者认为只要讲好了查询，这本书的工作就算是完成了。对于高级主题更是涉及很少。
　　在使用这本书的时候有几点需要注意：
　　1、参考每个DBMS的联机文档，因为每个DBMS使用的SQL语法都不一致，在SQLServer 2008上能运行的SQL在MySQL上就不一定能运行。作者提的SQL也不是所有都能在每一个DBMS上运行。比如在ACCESS上是不支持CREATE VIEW操作的（解决的办法是直接SELECT查询保存查询，并在另外一个查询中引用此查询名）。同时ACCESS不支持在定义数据表时使用Decimal数据类型。
　　2、一定要对每一个SQL试验一遍，甚至应该想出更多需要去查询的信息。尽可能多地让自己去想解决的方法和给自己出难题。如果觉得没有，可以到论坛上CSDN上找别入无法解决的问题。
　　——————————————————————————————-————
　　总体上，这本书是一本比较好的入门书。对于尽了解SQL是很有帮助的。
初学者入门SQL很好的书，也是快速重温常用SQL的书。
好久前读过，Mark下。
请问这个是不是要买
入门书里是讲的清楚的
写的没什么太复杂的，入门看看还是挺好的
　　失望。
　　下个月项目要用到数据库，翻了翻这本书。
　　只能说是sql基本命令，各种select用法，对数据库的原理和设计没有任何介绍。属于2天看完，1周忘掉的节奏。如果用到数据库忘记sql语法，建议看看http://www.w3school.com.cn/算了，或者直接google。
　　个人感觉，这本书用途不大。
　　第一感觉比较贵哈，但是这本书能浅显地告诉我一些我一直以来比较模糊的概念，而且能增加我学习sql的信心，推荐。
略简单
就是关键字介绍而已
最喜欢这种两天看完的书了
入门书
谁能想到自己现在每天都要写sql......
　　
　　　　注1：该笔记为未完成版（最后修改日期为2009.3.25）
　　　　注2：转帖请注明出处（笔记作者：城市行走者）
　　
　　第0章安装mysql以及建库、建表、导入数据
　　第1章了解SQL
　　1.1数据库基础
　　1.2 什么是SQL
　　1.3 动手实践
　　第2章检索数据
　　2.1 SELECT 语句
　　2.2 检索单个列
　　2.3 检索多个列
　　2.4 检索所有列
　　第3章排序检索数据
　　3.1 排序数据
　　3.2 按多个列排序
　　3.3 按列位置排序
　　3.4 指定排序方向
　　第4章过滤数据
　　4.1 使用WHERE子句
　　4.2 WHERE子句操作符
　　4.2.1 检查单个值
　　4.2.2 不匹配检查
　　4.2.3 范围值检查
　　4.2.4 空值检查
　　第 5 章高级数据过滤
　　5.1 组合WHERE子句
　　5.1.1 AND操作符（与运算）
　　5.1.2 OR操作符（或运算）
　　5.1.3 计算次序（操作符的优先级）
　　5.2 IN操作符
　　5.3 NOT操作符
　　第6章用通配符进行过滤
　　6.1 LIKE操作符
　　6.1.1 百分号（%）通配符
　　6.1.2 下划线（_）通配符
　　6.1.3 方括号（[]）通配符
　　6.2 使用通配符的技巧
　　附录：MySQL正则表达式
　　第7章创建计算字段
　　7.1 计算字段
　　7.2 拼接字段
　　7.3 执行算术计算
　　第8章使用数据处理函数
　　8.1 函数
　　8.2 使用函数
　　8.2.1 文本处理函数
　　8.2.2 日期和时间处理函数
　　8.2.3 数值处理函数
　　第9章汇总数据
　　9.1 聚集函数
　　9.2 聚集不同值
　　9.3 组合聚集函数
　　第10章分组数据
　　10.1 数据分组
　　10.2 创建分组
　　10.3 过滤分组
　　10.4 分组和排序
　　10.5 SELECT子句顺序
　　第11章使用子查询
　　11.1 子查询
　　11.2 利用子查询进行过滤
　　11.3 作为计算字段使用子查询
　　第12章联结表（join table）
　　12.1 联结
　　12.1.1 关系表
　　12.2 创建联结
　　12.2.2 内部联结
　　12.2.3 联结多个表
　　第13章创建高级联结
　　13.1 使用表别名
　　13.2 使用不同类型的联结
　　13.2.1 自联结
　　13.2.2 自然联结
　　13.2.3 外部联结
　　13.3 使用带聚集函数的联结
　　13.4 使用联结和联结条件
　　第14章组合查询
　　14.1 组合查询
　　14.2 创建组合查询
　　14.2.1 使用UNION
　　14.2.2 UNION规则
　　14.2.3 包含或取消重复的行
　　14.2.4 对组合查询排序
　　第15章插入数据
　　15.1 插入数据
　　15.1.1 插入完整的行
　　15.1.2 插入部分行
　　15.1.3 插入检索出的数据
　　15.2 从一个表复制到另一个表
　　第16章更新和删除数据
　　16.1 更新数据
　　16.2 删除数据
　　16.3 更新和删除的指导原则
　　第17章创建和操纵表
　　17.1 创建表
　　17.1.1 表创建基础
　　17.1.2 使用NULL值
　　17.1.3 制定默认值
　　17.2 更新表结构
　　17.3 删除表
　　17.4 重命名表名
　　第18章使用视图
　　18.1 视图
　　18.1.1 为什使用视图
　　18.1.2 视图的规则和限制
　　18.2 创建视图
　　18.2.1 利用视图简化复杂的联结
　　18.2.2 用视图重新格式化检索出的数据
　　18.2.3 用视图过滤不想要的数据
　　18.2.4 使用视图与计算字段
　　18.3 小结
　　第19章使用存储过程
　　附录： Oracle 和 mysql 的一些简单SQL操作命令对比
　　
　　第0章安装mysql以及建库、建表、导入数据
　　安装mysql时，向导建立的管理员用户和密码
　　root：lvhejia001;'
　　
　　一、连接mysql。
　　
　　 1、首先在打开DOS窗口，再键入命令mysql -uroot -p，回车后提示你输密码。
　　2、直接利用开始菜单！开始----程序---mysql5.0
　　
　　二、建库、建表、导入数据
　　1、显示数据库列表。
　　例子：
　　mysql> show tables;
　　+-------------------+
　　| Tables_in_example |
　　+-------------------+
　　| customers |
　　| orderitems |
　　| orders |
　　| products |
　　| vendors |
　　+-------------------+
　　5 rows in set (0.00 sec)
　　刚开始时才两个数据库：mysql和test。 mysql库很重要它里面有mysql的系统信息，
　　我们改密码和新增用户，实际上就是用这个库进行操作。
　　
　　2、显示库中的数据表：
　　语法：use 数据库名；／／打开库，学过FOXBASE的一定不会陌生吧
　　 show 表名;
　　
　　3、显示数据表的结构：
　　语法：describe 表名;
　　
　　4、建库：
　　语法：create database 库名;
　　
　　例子：
　　mysql> create database example;
　　Query OK, 1 row affected (0.00 sec)
　　
　　mysql> use example;
　　Database changed
　　
　　mysql> show tables;
　　Empty set (0.00 sec)
　　
　　
　　
　　5、建表：
　　语法：use 库名；
　　 create table 表名(字段设定列表)；
　　
　　使用Ben Forta提供的例子，直接复制粘贴。
　　-------------------------
　　-- Create Customers table
　　-------------------------
　　CREATE TABLE Customers
　　(
　　 cust_id char(10) NOT NULL ,
　　 cust_name char(50) NOT NULL ,
　　 cust_address char(50) NULL ,
　　 cust_city char(50) NULL ,
　　 cust_state char(5) NULL ,
　　 cust_zip char(10) NULL ,
　　 cust_country char(50) NULL ,
　　 cust_contact char(50) NULL ,
　　 cust_email char(255) NULL
　　);
　　……
　　无错误提示，再检查一下
　　mysql> show tables;
　　+-------------------+
　　| Tables_in_example |
　　+-------------------+
　　| customers |
　　| orderitems |
　　| orders |
　　| products |
　　| vendors |
　　+-------------------+
　　5 rows in set (0.00 sec)
　　
　　6、导入数据
　　还是使用Ben Forta提供的例子，直接复制粘贴。
　　---------------------------
　　-- Populate Customers table
　　---------------------------
　　INSERT INTO Customers(cust_id, cust_name, cust_address, cust_city, cust_state, cust_zip, cust_country, cust_contact, cust_email)
　　VALUES('1000000001', 'Village Toys', '200 Maple Lane', 'Detroit', 'MI', '44444', 'USA', 'John Smith', 'sales@villagetoys.com');
　　…… ……
　　
　　无错误提示
　　第1章了解SQL
　　1.1数据库基础
　　1.1.1 数据库（database）：保存有组织的数据的仓库（数据集合）。
　　1.1.2 表（table）：一种结构化的文件。
　　1.1.3 列（column）：表中的一个字段（field）。
　　数据类型（data type）：每列都有相应的数据类型，它限制或容许该列中存储的数据。
　　注意：虽然大多数的数据类型得到一致的支持，但许多更为高级的数据类型却不是这样。更糟的是，我们偶热会发现相同的数据类型在不同的DBMS中具有不同的名称。对此用户毫无办法，重要的是在创建表结构时要记住这些差异。
　　1.1.4 行（row）：表中的一个记录（record）。
　　1.1.5 主键（primary key）：一列（或一组列），其值能够唯一标识表中的每一列。
　　作为主键的列，需要满足以下条件：
　　1、任意两行都不具有相同的主键值；
　　2、每一行都必须具有一个主键值（主键列不允许NULL值）；
　　3、主键列中的值不允许修改或更新；
　　4、主键值不能重用（如果某行从表中删除，它的主键不能赋给以后的新行）
　　
　　1.2 什么是SQL
　　SQL(Structured Query Language)：结构化查询语言，是一种专门用来与数据库通信的语言。
　　注意：标准SQL有ANSI标准委员会管理，从而成为ANSI SQL。各个DBMS供应商通过增加语句或指令，对标准SQL进行扩展。
　　
　　1.3 动手实践
　　这里使用的DBMS为MySQL。
　　第2章检索数据
　　2.1 SELECT 语句
　　关键字（keyword）：作为SQL组成部分的保留字。
　　附录E ——SQL保留字（略）
　　
　　2.2 检索单个列
　　mysql> select prod_name
　　 -> from products;
　　
　　+---------------------+
　　| prod_name |
　　+---------------------+
　　| Fish bean bag toy |
　　| Bird bean bag toy |
　　| Rabbit bean bag toy |
　　| 8 inch teddy bear |
　　| 12 inch teddy bear |
　　| 18 inch teddy bear |
　　| Raggedy Ann |
　　| King doll |
　　| Queen doll |
　　+---------------------+
　　9 rows in set (0.20 sec)
　　
　　注意：1、SQL语句可以分行。
　　 2、多条SQL语句必须以分号（；）分隔。
　　 3、SQL语句不区分大小写。
　　
　　2.3 检索多个列
　　列名之间必须以逗号分隔。
　　mysql> select prod_id, prod_name, prod_price
　　 -> from products;
　　
　　+---------+---------------------+------------+
　　| prod_id | prod_name | prod_price |
　　+---------+---------------------+------------+
　　| BNBG01 | Fish bean bag toy | 3.49 |
　　| BNBG02 | Bird bean bag toy | 3.49 |
　　| BNBG03 | Rabbit bean bag toy | 3.49 |
　　| BR01 | 8 inch teddy bear | 5.99 |
　　| BR02 | 12 inch teddy bear | 8.99 |
　　| BR03 | 18 inch teddy bear | 11.99 |
　　| RGAN01 | Raggedy Ann | 4.99 |
　　| RYL01 | King doll | 9.49 |
　　| RYL02 | Queen doll | 9.49 |
　　+---------+---------------------+------------+
　　9 rows in set (0.00 sec)
　　
　　2.4 检索所有列
　　通配符——星号（*）
　　mysql> select *
　　 -> from products;
　　第3章排序检索数据
　　3.1 排序数据
　　mysql> select prod_name
　　 -> from products
　　 -> order by prod_name;
　　+---------------------+
　　| prod_name |
　　+---------------------+
　　| 12 inch teddy bear |
　　| 18 inch teddy bear |
　　| 8 inch teddy bear |
　　| Bird bean bag toy |
　　| Fish bean bag toy |
　　| King doll |
　　| Queen doll |
　　| Rabbit bean bag toy |
　　| Raggedy Ann |
　　+---------------------+
　　9 rows in set (0.16 sec)
　　
　　注意：order by子句必须是select语句中的最后一条子句。
　　
　　3.2 按多个列排序
　　
　　mysql> select prod_id, prod_price, prod_name
　　 -> from products
　　 -> order by prod_price, prod_name;
　　
　　+---------+------------+---------------------+
　　| prod_id | prod_price | prod_name |
　　+---------+------------+---------------------+
　　| BNBG02 | 3.49 | Bird bean bag toy |
　　| BNBG01 | 3.49 | Fish bean bag toy |
　　| BNBG03 | 3.49 | Rabbit bean bag toy |
　　| RGAN01 | 4.99 | Raggedy Ann |
　　| BR01 | 5.99 | 8 inch teddy bear |
　　| BR02 | 8.99 | 12 inch teddy bear |
　　| RYL01 | 9.49 | King doll |
　　| RYL02 | 9.49 | Queen doll |
　　| BR03 | 11.99 | 18 inch teddy bear |
　　+---------+------------+---------------------+
　　9 rows in set (0.00 sec)
　　
　　3.3 按列位置排序
　　mysql> select prod_id, prod_price, prod_name
　　 -> from products
　　 -> order by 2, 3;
　　
　　+---------+------------+---------------------+
　　| prod_id | prod_price | prod_name |
　　+---------+------------+---------------------+
　　| BNBG02 | 3.49 | Bird bean bag toy |
　　| BNBG01 | 3.49 | Fish bean bag toy |
　　| BNBG03 | 3.49 | Rabbit bean bag toy |
　　| RGAN01 | 4.99 | Raggedy Ann |
　　| BR01 | 5.99 | 8 inch teddy bear |
　　| BR02 | 8.99 | 12 inch teddy bear |
　　| RYL01 | 9.49 | King doll |
　　| RYL02 | 9.49 | Queen doll |
　　| BR03 | 11.99 | 18 inch teddy bear |
　　+---------+------------+---------------------+
　　9 rows in set (0.00 sec)
　　
　　3.4 指定排序方向
　　排序时默认为升序ASC（ASDENDING），如果需要降序，则通过关键字DESC（DESCENDING）。
　　mysql> select prod_id, prod_price, prod_name
　　 -> from products
　　 -> order by prod_price desc;
　　
　　+---------+------------+---------------------+
　　| prod_id | prod_price | prod_name |
　　+---------+------------+---------------------+
　　| BR03 | 11.99 | 18 inch teddy bear |
　　| RYL01 | 9.49 | King doll |
　　| RYL02 | 9.49 | Queen doll |
　　| BR02 | 8.99 | 12 inch teddy bear |
　　| BR01 | 5.99 | 8 inch teddy bear |
　　| RGAN01 | 4.99 | Raggedy Ann |
　　| BNBG01 | 3.49 | Fish bean bag toy |
　　| BNBG02 | 3.49 | Bird bean bag toy |
　　| BNBG03 | 3.49 | Rabbit bean bag toy |
　　+---------+------------+---------------------+
　　9 rows in set (0.00 sec)
　　
　　注意：DESC关键字之应用到直接位于其前面的列名。如果想对多个列进行排序，必须对每个列指定DESC关键字。
　　第4章过滤数据
　　4.1 使用WHERE子句
　　mysql> select prod_name, prod_price
　　 -> from products
　　 -> where prod_price = 3.49;
　　
　　+---------------------+------------+
　　| prod_name | prod_price |
　　+---------------------+------------+
　　| Fish bean bag toy | 3.49 |
　　| Bird bean bag toy | 3.49 |
　　| Rabbit bean bag toy | 3.49 |
　　+---------------------+------------+
　　3 rows in set (0.00 sec)
　　
　　4.2 WHERE子句操作符
　　
　　操作符说明
　　=
　　!=
　　<>
　　<
　　<=
　　>
　　>=
　　BETWEEN
　　IS UNLL
　　
　　4.2.1 检查单个值
　　mysql> select prod_name, prod_price
　　 -> from products
　　 -> where prod_price < 10;
　　
　　+---------------------+------------+
　　| prod_name | prod_price |
　　+---------------------+------------+
　　| Fish bean bag toy | 3.49 |
　　| Bird bean bag toy | 3.49 |
　　| Rabbit bean bag toy | 3.49 |
　　| 8 inch teddy bear | 5.99 |
　　| 12 inch teddy bear | 8.99 |
　　| Raggedy Ann | 4.99 |
　　| King doll | 9.49 |
　　| Queen doll | 9.49 |
　　+---------------------+------------+
　　8 rows in set (0.00 sec)
　　4.2.2 不匹配检查
　　mysql> select vend_id, prod_name
　　 -> from products
　　 -> where vend_id != 'DLL01';
　　+---------+--------------------+
　　| vend_id | prod_name |
　　+---------+--------------------+
　　| BRS01 | 8 inch teddy bear |
　　| BRS01 | 12 inch teddy bear |
　　| BRS01 | 18 inch teddy bear |
　　| FNG01 | King doll |
　　| FNG01 | Queen doll |
　　+---------+--------------------+
　　5 rows in set (0.00 sec)
　　
　　注意：!=和<>通常可以互换。但是，并非所有的DBMS都支持这两种操作符。例如Microsoft Access支持<>而不支持!=。如有疑问，请参阅相应的DBMS文档。
　　4.2.3 范围值检查
　　mysql> select prod_name, prod_price
　　 -> from products
　　 -> where prod_price between 5 and 10;
　　
　　+--------------------+------------+
　　| prod_name | prod_price |
　　+--------------------+------------+
　　| 8 inch teddy bear | 5.99 |
　　| 12 inch teddy bear | 8.99 |
　　| King doll | 9.49 |
　　| Queen doll | 9.49 |
　　+--------------------+------------+
　　4 rows in set (0.00 sec)
　　4.2.4 空值检查
　　mysql> select vend_name, vend_state
　　 -> from vendors
　　 -> where vend_state is null;
　　
　　+----------------+------------+
　　| vend_name | vend_state |
　　+----------------+------------+
　　| Fun and Games | NULL |
　　| Jouets et ours | NULL |
　　+----------------+------------+
　　2 rows in set (0.00 sec)
　　第 5 章高级数据过滤
　　5.1 组合WHERE子句
　　操作符（operateor）：用来联接或改变WHERE子句中的子句的关键词。也称逻辑操作符（logical operator）。
　　5.1.1 AND操作符（与运算）
　　mysql> select prod_id, prod_price, prod_name
　　 -> from products
　　 -> where vend_id = 'DLL01' and prod_price <= 4;
　　
　　+---------+------------+---------------------+
　　| prod_id | prod_price | prod_name |
　　+---------+------------+---------------------+
　　| BNBG01 | 3.49 | Fish bean bag toy |
　　| BNBG02 | 3.49 | Bird bean bag toy |
　　| BNBG03 | 3.49 | Rabbit bean bag toy |
　　+---------+------------+---------------------+
　　3 rows in set (0.00 sec)
　　5.1.2 OR操作符（或运算）
　　mysql> select vend_id, prod_name, prod_price
　　 -> from products
　　 -> where vend_id = 'DLL01' or vend_id = 'BRS01';
　　+---------+---------------------+------------+
　　| vend_id | prod_name | prod_price |
　　+---------+---------------------+------------+
　　| DLL01 | Fish bean bag toy | 3.49 |
　　| DLL01 | Bird bean bag toy | 3.49 |
　　| DLL01 | Rabbit bean bag toy | 3.49 |
　　| BRS01 | 8 inch teddy bear | 5.99 |
　　| BRS01 | 12 inch teddy bear | 8.99 |
　　| BRS01 | 18 inch teddy bear | 11.99 |
　　| DLL01 | Raggedy Ann | 4.99 |
　　+---------+---------------------+------------+
　　
　　注意：事实上，许多DBMS在OR子句的第一个条件满足的情况下，不再计算第二个条件（即，第一个条件满足时，不管第二个条件是否满足，相应的行都将被检索出来）。
　　5.1.3 计算次序（操作符的优先级）
　　以下列表显示了操作符优先级的由低到高的顺序。排列在同一行的操作符具有相同的优先级。
　　
　　:=
　　||, OR, XOR
　　&&, AND
　　NOT
　　BETWEEN, CASE, WHEN, THEN, ELSE
　　=, <=>, >=, >, <=, <, <>, !=, IS, LIKE, REGEXP, IN
　　|
　　&
　　<<, >>
　　-, +
　　*, /, DIV, %, MOD
　　^
　　- (一元减号), ~ (一元比特反转)
　　!
　　BINARY, COLLATE
　　
　　注意：不要过分依赖默认的优先级。任何时候使用具有AND和OR的操作符的WHERE子句时，都应该使用圆括号明确的分组操作符。使用圆括号没有什么坏处，它能消除歧义。
　　5.2 IN操作符
　　mysql> select vend_id, prod_name, prod_price
　　 -> from products
　　 -> where vend_id = 'DLL01' or vend_id = 'BRS01';
　　
　　+---------+---------------------+------------+
　　| vend_id | prod_name | prod_price |
　　+---------+---------------------+------------+
　　| DLL01 | Fish bean bag toy | 3.49 |
　　| DLL01 | Bird bean bag toy | 3.49 |
　　| DLL01 | Rabbit bean bag toy | 3.49 |
　　| BRS01 | 8 inch teddy bear | 5.99 |
　　| BRS01 | 12 inch teddy bear | 8.99 |
　　| BRS01 | 18 inch teddy bear | 11.99 |
　　| DLL01 | Raggedy Ann | 4.99 |
　　+---------+---------------------+------------+
　　7 rows in set (0.00 sec)
　　
　　注意：IN操作符可以完成OR操作符完全相同的功能。
　　
　　IN操作符最大的优点是可以包含其他SELECT语句，使得能够更动态的建立WHERE子句。详细介绍在第11章。
　　5.3 NOT操作符
　　mysql> select vend_id, prod_name, prod_price
　　 -> from products
　　 -> where not vend_id = 'DLL01' ;
　　
　　+---------+--------------------+------------+
　　| vend_id | prod_name | prod_price |
　　+---------+--------------------+------------+
　　| BRS01 | 8 inch teddy bear | 5.99 |
　　| BRS01 | 12 inch teddy bear | 8.99 |
　　| BRS01 | 18 inch teddy bear | 11.99 |
　　| FNG01 | King doll | 9.49 |
　　| FNG01 | Queen doll | 9.49 |
　　+---------+--------------------+------------+
　　5 rows in set (0.00 sec)
　　
　　注意：NOT操作符在复杂子句中用处更大，比如与IN操作符联合使用——NOT IN。
　　第6章用通配符进行过滤
　　6.1 LIKE操作符
　　通配符（wildcard）：用来匹配值（文本字段，即“串”）的一部分的特殊字符。
　　搜索模式（search pattern）：由字面值、通配符或者两者组合构成的搜索条件。
　　6.1.1 百分号（%）通配符
　　百分号（%）表示任何字符出现任意次数。
　　mysql> select prod_name
　　 -> from products
　　 -> where prod_name like 'fish%';
　　
　　+-------------------+
　　| prod_name |
　　+-------------------+
　　| Fish bean bag toy |
　　+-------------------+
　　1 row in set (0.01 sec)
　　
　　注意：根据DBMS的不同及其配置，搜索可以是区分大小写的！
　　
　　mysql> select prod_name
　　 -> from products
　　 -> where prod_name like 'f%y';
　　
　　+-------------------+
　　| prod_name |
　　+-------------------+
　　| Fish bean bag toy |
　　+-------------------+
　　1 row in set (0.00 sec)
　　注意：要特别小心后面所跟的空格。许多DBMS，包括Microsoft Access，都用空格来填补字段内容。
　　6.1.2 下划线（_）通配符
　　下划线（_）表示任意单个字符。
　　mysql> select prod_name
　　 -> from products
　　 -> where prod_name like '_ inch teddy bear';
　　
　　+-------------------+
　　| prod_name |
　　+-------------------+
　　| 8 inch teddy bear |
　　+-------------------+
　　1 row in set (0.00 sec)
　　
　　mysql> select prod_name
　　 -> from products
　　 -> where prod_name like '% inch teddy bear';
　　
　　+--------------------+
　　| prod_name |
　　+--------------------+
　　| 8 inch teddy bear |
　　| 12 inch teddy bear |
　　| 18 inch teddy bear |
　　+--------------------+
　　3 rows in set (0.00 sec)
　　6.1.3 方括号（[]）通配符
　　方括号（[]）通配符：用来指定一个字符集。
　　注意：并不是所有的SBMS都支持方括号（[]）通配符
　　6.2 使用通配符的技巧
　　除非绝对有必要，否则不要把它们用在搜索模式的开始处。把通配符置于搜索模式的开始处，搜索起来是最慢的。
　　
　　
　　附录：MySQL正则表达式
　　
　　正则表达式是为复杂搜索指定模式的强大方式。
　　MySQL采用Henry Spencer的正则表达式实施，其目标是符合POSIX 1003.2。请参见附录C：感谢。MySQL采用了扩展的版本，以支持在SQL语句中与REGEXP操作符一起使用的模式匹配操作。请参见3.3.4.7节，“模式匹配”。
　　在本附录中，归纳了在MySQL中可用于REGEXP操作的特殊字符和结构，并给出了一些示例。本附录未包含可在Henry Spencer的regex(7)手册页面中发现的所有细节。该手册页面包含在MySQL源码分发版中，位于regex目录下的regex.7文件中。
　　正则表达式描述了一组字符串。最简单的正则表达式是不含任何特殊字符的正则表达式。例如，正则表达式hello匹配hello。
　　非平凡的正则表达式采用了特殊的特定结构，从而使得它们能够与1个以上的字符串匹配。例如，正则表达式hello|word匹配字符串hello或字符串word。
　　作为一个更为复杂的示例，正则表达式B[an]*s匹配下述字符串中的任何一个：Bananas，Baaaaas，Bs，以及以B开始、以s结束、并在其中包含任意数目a或n字符的任何其他字符串。
　　对于REGEXP操作符，正则表达式可以使用任何下述特殊字符和结构：
　　• ^
　　匹配字符串的开始部分。
　　mysql> SELECT 'fo\nfo' REGEXP '^fo$'; -> 0
　　mysql> SELECT 'fofo' REGEXP '^fo'; -> 1
　　• $
　　匹配字符串的结束部分。
　　mysql> SELECT 'fo\no' REGEXP '^fo\no$'; -> 1
　　mysql> SELECT 'fo\no' REGEXP '^fo$'; -> 0
　　• .
　　匹配任何字符（包括回车和新行）。
　　mysql> SELECT 'fofo' REGEXP '^f.*$'; -> 1
　　mysql> SELECT 'fo\r\nfo' REGEXP '^f.*$'; -> 1
　　• a*
　　匹配0或多个a字符的任何序列。
　　mysql> SELECT 'Ban' REGEXP '^Ba*n'; -> 1
　　mysql> SELECT 'Baaan' REGEXP '^Ba*n'; -> 1
　　mysql> SELECT 'Bn' REGEXP '^Ba*n'; -> 1
　　• a+
　　匹配1个或多个a字符的任何序列。
　　mysql> SELECT 'Ban' REGEXP '^Ba+n'; -> 1
　　mysql> SELECT 'Bn' REGEXP '^Ba+n'; -> 0
　　• a?
　　匹配0个或1个a字符。
　　mysql> SELECT 'Bn' REGEXP '^Ba?n'; -> 1
　　mysql> SELECT 'Ban' REGEXP '^Ba?n'; -> 1
　　mysql> SELECT 'Baan' REGEXP '^Ba?n'; -> 0
　　• de|abc
　　匹配序列de或abc。
　　mysql> SELECT 'pi' REGEXP 'pi|apa'; -> 1
　　mysql> SELECT 'axe' REGEXP 'pi|apa'; -> 0
　　mysql> SELECT 'apa' REGEXP 'pi|apa'; -> 1
　　mysql> SELECT 'apa' REGEXP '^(pi|apa)$'; -> 1
　　mysql> SELECT 'pi' REGEXP '^(pi|apa)$'; -> 1
　　mysql> SELECT 'pix' REGEXP '^(pi|apa)$'; -> 0
　　• (abc)*
　　匹配序列abc的0个或多个实例。
　　mysql> SELECT 'pi' REGEXP '^(pi)*$'; -> 1
　　mysql> SELECT 'pip' REGEXP '^(pi)*$'; -> 0
　　mysql> SELECT 'pipi' REGEXP '^(pi)*$'; -> 1
　　• {1}, {2,3}
　　{n}或{m,n}符号提供了编写正则表达式的更通用方式，能够匹配模式的很多前述原子（或“部分”）。m和n均为整数。
　　o a*
　　可被写入为a{0,}。
　　o a+
　　可被写入为a{1,}。
　　o a?
　　可被写入为a{0,1}。
　　更准确地讲，a{n}与a的n个实例准确匹配。a{n,}匹配a的n个或更多实例。a{m,n}匹配a的m～n个实例，包含m和n。
　　m和n必须位于0～RE_DUP_MAX（默认为255）的范围内，包含0和RE_DUP_MAX。如果同时给定了m和n，m必须小于或等于n。
　　mysql> SELECT 'abcde' REGEXP 'a[bcd]{2}e'; -> 0
　　mysql> SELECT 'abcde' REGEXP 'a[bcd]{3}e'; -> 1
　　mysql> SELECT 'abcde' REGEXP 'a[bcd]{1,10}e'; -> 1
　　• [a-dX], [^a-dX]
　　匹配任何是（或不是，如果使用^的话）a、b、c、d或X的字符。两个其他字符之间的“-”字符构成一个范围，与从第1个字符开始到第2个字符之间的所有字符匹配。例如，[0-9]匹配任何十进制数字。要想包含文字字符“]”，它必须紧跟在开括号“[”之后。要想包含文字字符“-”，它必须首先或最后写入。对于[]对内未定义任何特殊含义的任何字符，仅与其本身匹配。
　　mysql> SELECT 'aXbc' REGEXP '[a-dXYZ]'; -> 1
　　mysql> SELECT 'aXbc' REGEXP '^[a-dXYZ]$'; -> 0
　　mysql> SELECT 'aXbc' REGEXP '^[a-dXYZ]+$'; -> 1
　　mysql> SELECT 'aXbc' REGEXP '^[^a-dXYZ]+$'; -> 0
　　mysql> SELECT 'gheis' REGEXP '^[^a-dXYZ]+$'; -> 1
　　mysql> SELECT 'gheisa' REGEXP '^[^a-dXYZ]+$'; -> 0
　　• [.characters.]
　　在括号表达式中（使用[和]），匹配用于校对元素的字符序列。字符为单个字符或诸如新行等字符名。在文件regexp/cname.h中，可找到字符名称的完整列表。
　　mysql> SELECT '~' REGEXP '[[.~.]]'; -> 1
　　mysql> SELECT '~' REGEXP '[[.tilde.]]'; -> 1
　　• [=character_class=]
　　在括号表达式中（使用[和]），[=character_class=]表示等同类。它与具有相同校对值的所有字符匹配，包括它本身，例如，如果o和(+)均是等同类的成员，那么[[=o=]]、[[=(+)=]]和[o(+)]是同义词。等同类不得用作范围的端点。
　　• [:character_class:]
　　在括号表达式中（使用[和]），[:character_class:]表示与术语类的所有字符匹配的字符类。标准的类名称是：
　　alnum 文字数字字符
　　alpha 文字字符
　　blank 空白字符
　　cntrl 控制字符
　　digit 数字字符
　　graph 图形字符
　　lower 小写文字字符
　　print 图形或空格字符
　　punct 标点字符
　　space 空格、制表符、新行、和回车
　　upper 大写文字字符
　　xdigit 十六进制数字字符
　　它们代表在ctype(3)手册页面中定义的字符类。特定地区可能会提供其他类名。字符类不得用作范围的端点。
　　mysql> SELECT 'justalnums' REGEXP '[[:alnum:]]+'; -> 1
　　mysql> SELECT '!!' REGEXP '[[:alnum:]]+'; -> 0
　　• [[:<:]], [[:>:]]
　　这些标记表示word边界。它们分别与word的开始和结束匹配。word是一系列字字符，其前面和后面均没有字字符。字字符是alnum类中的字母数字字符或下划线(_)。
　　mysql> SELECT 'a word a' REGEXP '[[:<:]]word[[:>:]]'; -> 1
　　mysql> SELECT 'a xword a' REGEXP '[[:<:]]word[[:>:]]'; -> 0
　　要想在正则表达式中使用特殊字符的文字实例，应在其前面加上2个反斜杠“\”字符。MySQL解析程序负责解释其中一个，正则表达式库负责解释另一个。例如，要想与包含特殊字符“+”的字符串“1+2”匹配，在下面的正则表达式中，只有最后一个是正确的：
　　mysql> SELECT '1+2' REGEXP '1+2'; -> 0
　　mysql> SELECT '1+2' REGEXP '1\+2'; -> 0
　　mysql> SELECT '1+2' REGEXP '1\\+2'; -> 1
　　
　　这是MySQL参考手册的翻译版本，关于MySQL参考手册，请访问dev.mysql.com。原始参考手册为英文版，与英文版参考手册相比，本翻译版可能不是最新的。
　　
　　第7章创建计算字段
　　7.1 计算字段
　　计算字段并不是实际存在出数据库中。计算字段是运行时在SELECT语句中创建的。
　　字段（field）与列（column）：数据库中一般称为列（column），而术语字段（field）通常用在计算字段的连接上。
　　7.2 拼接字段
　　拼接（concatenate）：将值联接到一起构成单个值。操作符根据不同的DBMS而有差异。
　　Oracle、DB2、Sybase使用||。
　　SQL Server和Sybase使用加号（+）。
　　MySQL使用CONCAT函数（拼接函数concatenate）。
　　
　　mysql> select CONCAT(vend_name ,' (',vend_country,')')
　　 -> from vendors;
　　
　　+------------------------------------------+
　　| concat(vend_name ,' (',vend_country,')') |
　　+------------------------------------------+
　　| Bear Emporium (USA) |
　　| Bears R Us (USA) |
　　| Doll House Inc. (USA) |
　　| Fun and Games (England) |
　　| Furball Inc. (USA) |
　　| Jouets et ours (France) |
　　+------------------------------------------+
　　6 rows in set (0.00 sec)
　　
　　TRIM函数：去掉空格（略）
　　
　　使用别名，关键词为AS（也可省略）。
　　mysql> select concat(vend_name ,' (',vend_country,')') AS vend_title
　　 -> from vendors;
　　+-------------------------+
　　| vend_title |
　　+-------------------------+
　　| Bear Emporium (USA) |
　　| Bears R Us (USA) |
　　| Doll House Inc. (USA) |
　　| Fun and Games (England) |
　　| Furball Inc. (USA) |
　　| Jouets et ours (France) |
　　+-------------------------+
　　6 rows in set (0.00 sec)
　　
　　mysql> select concat(vend_name ,' (',vend_country,')') vend_title
　　 -> from vendors;
　　+-------------------------+
　　| vend_title |
　　+-------------------------+
　　| Bear Emporium (USA) |
　　| Bears R Us (USA) |
　　| Doll House Inc. (USA) |
　　| Fun and Games (England) |
　　| Furball Inc. (USA) |
　　| Jouets et ours (France) |
　　+-------------------------+
　　6 rows in set (0.00 sec)
　　
　　注意：别名一般是一个单词（可用下划线连接多个单词组成）。
　　7.3 执行算术计算
　　SQL算术操作符
　　+
　　-
　　*
　　/
　　
　　
　　第8章使用数据处理函数
　　8.1 函数
　　与几乎所有的DBMS都同等地支持SQL语句不同，每一个DBMS都有特定的函数。
　　所以，SQL函数是不可移植的。
　　可移植（portable）：所编写的代码可以在多个系统上运行。
　　
　　注意：是否应该使用函数？如果你决定使用函数，应该保证做好代码注释，以便以后你（或者其他人）能确切的知道所编写SQL代码的含义。
　　8.2 使用函数
　　8.2.1 文本处理函数
　　函数说明
　　LEFT( )
　　LENGTH( )
　　LOWER( )
　　LTRIM( )
　　RTRIM( )
　　RIGHT( )
　　SOUNDEX( ) 语音匹配
　　UPPER( )
　　
　　mysql> select upper( vend_name)
　　 -> from vendors;
　　+-------------------+
　　| upper( vend_name) |
　　+-------------------+
　　| BEAR EMPORIUM |
　　| BEARS R US |
　　| DOLL HOUSE INC. |
　　| FUN AND GAMES |
　　| FURBALL INC. |
　　| JOUETS ET OURS |
　　+-------------------+
　　6 rows in set (0.00 sec)
　　8.2.2 日期和时间处理函数
　　 Oracle mysql
　　日期函数 SQL> select sysdate from dual; mysql> select now();
　　mysql> select sysdate();
　　mysql> select curdate();
　　mysql> select current_date;
　　mysql> select curtime();
　　mysql> select current_time;
　　日期格式化 SQL> select to_char(sysdate,'yyyy-mm-dd') from dual;
　　SQL> select to_char(sysdate,'hh24-mi-ss') from dual; mysql> select date_format(now(),'%Y-%m-%d');
　　mysql> select time_format(now(),'%H-%i-%S');
　　
　　mysql> select order_date
　　 -> from orders;
　　+---------------------+
　　| order_date |
　　+---------------------+
　　| 2004-05-01 00:00:00 |
　　| 2004-01-12 00:00:00 |
　　| 2004-01-30 00:00:00 |
　　| 2004-02-03 00:00:00 |
　　| 2004-02-08 00:00:00 |
　　+---------------------+
　　5 rows in set (0.00 sec)
　　
　　mysql> select order_date
　　 -> from orders
　　 -> where month(order_date) = 02;
　　+---------------------+
　　| order_date |
　　+---------------------+
　　| 2004-02-03 00:00:00 |
　　| 2004-02-08 00:00:00 |
　　+---------------------+
　　2 rows in set (0.00 sec)
　　
　　mysql> select order_date
　　 -> from orders
　　 -> where date_format(order_date, '%m') = 02;
　　+---------------------+
　　| order_date |
　　+---------------------+
　　| 2004-02-03 00:00:00 |
　　| 2004-02-08 00:00:00 |
　　+---------------------+
　　2 rows in set (0.00 sec)
　　8.2.3 数值处理函数
　　在主要DBMS函数中，数值函数的统一性最高。
　　函数说明
　　ABS( ) 绝对值
　　COS( )
　　EXP( ) 指数值
　　PI( ) 圆周率
　　SIN( )
　　SQRT( ) 平方根
　　TAN( )
　　
　　第9章汇总数据
　　9.1 聚集函数
　　聚集函数（aggregate function）：从多个输入行中计算，并返回单个值的函数。
　　
　　SQL聚集函数
　　AVG( )
　　COUNT( )
　　MAX( )
　　MIN( )
　　SUM( )
　　
　　COUNT( )函数有两种使用方式：
　　1、使用COUNT(*)对表中行的数据进行计数，不管表的列中包含的是空值（NULL）还是非空值。
　　2、使用COUNT(column)对特定列中具有值的行进行计数，忽略空值（NULL）。
　　9.2 聚集不同值
　　DISTINCT参数：只包含不同的值。
　　9.3 组合聚集函数
　　（略）
　　第10章分组数据
　　10.1 数据分组
　　分组允许把数据分为多个逻辑组，以便能对每个组进行聚集计算。
　　10.2 创建分组
　　分组在SELECT语句的GROUP BY子句中创建。
　　mysql> select vend_id, count(*) num_prods
　　 -> from products
　　 -> group by vend_id;
　　+---------+-----------+
　　| vend_id | num_prods |
　　+---------+-----------+
　　| BRS01 | 3 |
　　| DLL01 | 4 |
　　| FNG01 | 2 |
　　+---------+-----------+
　　3 rows in set (0.00 sec)
　　
　　mysql> select vend_id
　　 -> from products;
　　+---------+
　　| vend_id |
　　+---------+
　　| BRS01 |
　　| BRS01 |
　　| BRS01 |
　　| DLL01 |
　　| DLL01 |
　　| DLL01 |
　　| DLL01 |
　　| FNG01 |
　　| FNG01 |
　　+---------+
　　9 rows in set (0.00 sec)
　　
　　mysql> select vend_id
　　 -> from products
　　 -> group by vend_id;
　　+---------+
　　| vend_id |
　　+---------+
　　| BRS01 |
　　| DLL01 |
　　| FNG01 |
　　+---------+
　　3 rows in set (0.00 sec)
　　
　　注意：除聚集语句外，SELECT语句中的每个列都必须在GROUP BY子句中给出。
　　下面是一个反例：
　　mysql> select prod_name, count(*) num_prods
　　 -> from products
　　 -> group by vend_id;
　　+-------------------+-----------+
　　| prod_name | num_prods |
　　+-------------------+-----------+
　　| 8 inch teddy bear | 3 |
　　| Fish bean bag toy | 4 |
　　| King doll | 2 |
　　+-------------------+-----------+
　　3 rows in set (0.00 sec)
　　输出结果没有意义。
　　
　　mysql> select vend_id, prod_name
　　 -> from products;
　　+---------+---------------------+
　　| vend_id | prod_name |
　　+---------+---------------------+
　　| DLL01 | Fish bean bag toy |
　　| DLL01 | Bird bean bag toy |
　　| DLL01 | Rabbit bean bag toy |
　　| BRS01 | 8 inch teddy bear |
　　| BRS01 | 12 inch teddy bear |
　　| BRS01 | 18 inch teddy bear |
　　| DLL01 | Raggedy Ann |
　　| FNG01 | King doll |
　　| FNG01 | Queen doll |
　　+---------+---------------------+
　　9 rows in set (0.00 sec)
　　10.3 过滤分组
　　WHERE过滤行，而HAVING过滤分组。
　　HAVING支持所有的WHERE操作符。
　　注意：HAVING和WHERE的差别，WHERE在数据分组前进行过滤，HAVING在数据分组后进行过滤。也就是说，WHERE排出的行不包括在分组中。
　　mysql> select vend_id, count(*) num_prods
　　 -> from products
　　 -> group by vend_id
　　 -> having count(*) >= 3;
　　+---------+-----------+
　　| vend_id | num_prods |
　　+---------+-----------+
　　| BRS01 | 3 |
　　| DLL01 | 4 |
　　+---------+-----------+
　　2 rows in set (0.00 sec)
　　
　　HAVING和WHERE同时出现：
　　mysql> select vend_id, count(*) num_prods
　　 -> from products
　　 -> where prod_price >=4
　　 -> group by vend_id
　　 -> having count(*) >=2;
　　+---------+-----------+
　　| vend_id | num_prods |
　　+---------+-----------+
　　| BRS01 | 3 |
　　| FNG01 | 2 |
　　+---------+-----------+
　　2 rows in set (0.00 sec)
　　
　　mysql> select vend_id, count(*) num_prods
　　 -> from products
　　 -> group by vend_id;
　　+---------+-----------+
　　| vend_id | num_prods |
　　+---------+-----------+
　　| BRS01 | 3 |
　　| DLL01 | 4 |
　　| FNG01 | 2 |
　　+---------+-----------+
　　3 rows in set (0.00 sec)
　　10.4 分组和排序
　　GROUP BY的输出可能排序，也可能不排序。保证数据正确排序的方法是使用ORDER BY子句。
　　10.5 SELECT子句顺序
　　SELECT
　　FROM
　　WHERE
　　GROUP BY
　　HAVING
　　ORDER BY
　　第11章使用子查询
　　11.1 子查询
　　查询（query）：任何SQL语句都是查询。但此术语一般指SELECT语句。
　　子查询（subquery）：嵌套在其他查询中的查询。
　　11.2 利用子查询进行过滤
　　格式化SQL：可以把子查询分解为多行，并适当的进行缩进。
　　
　　注意：作为子查询的SELECT语句只能查询（返回）单个列。企图检索多个列将返回错误。
　　（例子略）
　　11.3 作为计算字段使用子查询
　　（例子略）
　　第12章联结表（join table）
　　12.1 联结
　　联结（join）：join常见不规范译法还有“联接”、“连接”。
　　12.1.1 关系表
　　理解关系表的最好方法是来看一个现实世界中的例子。
　　作者写得非常好，是我见过的最通俗易懂的！中文暂时略
　　英文如下：
　　The best way to understand relational tables is to look at a real-world example.
　　Suppose you had a database table containing a product catalog, with each catalog item in its own row. The kind of information you would store with each item would include a product description and price, along with vendor information about the company that creates the product.
　　Now suppose that you had multiple catalog items created by the same vendor. Where would you store the vendor information (things like vendor name, address, and contact information)? You wouldn't want to store that data along with the products for several reasons:
　　Because the vendor information is the same for each product that vendor produces, repeating the information for each product is a waste of time and storage space.
　　If vendor information changes (for example, if the vendor moves or his area code changes), you would need to update every occurrence of the vendor information.
　　When data is repeated (that is, the vendor information is used with each product), there is a high likelihood that the data will not be entered exactly the same way each time. Inconsistent data is extremely difficult to use in reporting.
　　The key here is that having multiple occurrences of the same data is never a good thing, and that principle is the basis for relational database design. Relational tables are designed so that information is split into multiple tables, one for each data type. The tables are related to each other through common values (and thus the relational in relational design).
　　In our example, you can create two tables, one for vendor information and one for product information. The Vendors table contains all the vendor information, one table row per vendor, along with a unique identifier for each vendor. This value, called a primary key, can be a vendor ID, or any other unique value.
　　The Products table stores only product information, and no vendor specific information other than the vendor ID (the Vendors table's primary key). This key relates the Vendors table to the Products table, and using this vendor ID enables you to use the Vendors table to find the details about the appropriate vendor.
　　What does this do for you? Well, consider the following:
　　Vendor information is never repeated, and so time and space are not wasted.
　　If vendor information changes, you can update a single record, the one in the Vendors table. Data in related tables does not change.
　　As no data is repeated, the data used is obviously consistent, making data reporting and manipulation much simpler.
　　The bottom line is that relational data can be stored efficiently and manipulated easily. Because of this, relational databases scale far better than nonrelational databases.
　　
　　Scale Able to handle an increasing load without failing. A well-designed database or application is said to scale well.
　　
　　
　　Why Use Joins?
　　As just explained, breaking data into multiple tables enables more efficient storage, easier manipulation, and greater scalability. But these benefits come with a price.
　　If data is stored in multiple tables, how can you retrieve that data with a single SELECT statement?
　　The answer is to use a join. Simply put, a join is a mechanism used to associate tables within a SELECT statement (and thus the name join). Using a special syntax, multiple tables can be joined so that a single set of output is returned, and the join associates the correct rows in each table on-the-fly.
　　
　　Using Interactive DBMS Tools It is important to understand that a join is not a physical entity—in other words, it does not exist in the actual database tables. A join is created by the DBMS as needed, and it persists for the duration of the query execution.
　　Many DBMSs provide graphical interfaces that can be used to define table relationships interactively. These tools can be invaluable in helping to maintain referential integrity. When using relational tables, it is important that only valid data is inserted into relational columns. Going back to the example, if an invalid vendor ID is stored in the Products table, those products would be inaccessible because they would not be related to any vendor. To prevent this from occurring, the database can be instructed to only allow valid values (ones present in the Vendors table) in the vendor ID column in the Products table. Referential integrity means that the DBMS enforces data integrity rules. And these rules are often managed through DBMS provided interfaces.
　　
　　12.2 创建联结
　　mysql> select vend_name, prod_name, prod_price
　　 -> from vendors, products
　　 -> where vendors.vend_id = products.vend_id;
　　+-----------------+---------------------+------------+
　　| vend_name | prod_name | prod_price |
　　+-----------------+---------------------+------------+
　　| Bears R Us | 8 inch teddy bear | 5.99 |
　　| Bears R Us | 12 inch teddy bear | 8.99 |
　　| Bears R Us | 18 inch teddy bear | 11.99 |
　　| Doll House Inc. | Fish bean bag toy | 3.49 |
　　| Doll House Inc. | Bird bean bag toy | 3.49 |
　　| Doll House Inc. | Rabbit bean bag toy | 3.49 |
　　| Doll House Inc. | Raggedy Ann | 4.99 |
　　| Fun and Games | King doll | 9.49 |
　　| Fun and Games | Queen doll | 9.49 |
　　+-----------------+---------------------+------------+
　　9 rows in set (0.03 sec)
　　
　　笛卡尔积（cartesian product）：由没有连接条件的表关系返回的结果为笛卡尔积。检索出的行数是第一个表的行数乘以第二个表的行数。
　　为了理解这一点，请看没有连接条件的SELECT语句及输出。
　　mysql> select vend_name, prod_name, prod_price
　　 -> from vendors, products;
　　+-----------------+---------------------+------------+
　　| vend_name | prod_name | prod_price |
　　+-----------------+---------------------+------------+
　　| Bear Emporium | Fish bean bag toy | 3.49 |
　　| Bears R Us | Fish bean bag toy | 3.49 |
　　| Doll House Inc. | Fish bean bag toy | 3.49 |
　　| Fun and Games | Fish bean bag toy | 3.49 |
　　| Furball Inc. | Fish bean bag toy | 3.49 |
　　| Jouets et ours | Fish bean bag toy | 3.49 |
　　| Bear Emporium | Bird bean bag toy | 3.49 |
　　| Bears R Us | Bird bean bag toy | 3.49 |
　　| Doll House Inc. | Bird bean bag toy | 3.49 |
　　| Fun and Games | Bird bean bag toy | 3.49 |
　　| Furball Inc. | Bird bean bag toy | 3.49 |
　　| Jouets et ours | Bird bean bag toy | 3.49 |
　　| Bear Emporium | Rabbit bean bag toy | 3.49 |
　　| Bears R Us | Rabbit bean bag toy | 3.49 |
　　| Doll House Inc. | Rabbit bean bag toy | 3.49 |
　　| Fun and Games | Rabbit bean bag toy | 3.49 |
　　| Furball Inc. | Rabbit bean bag toy | 3.49 |
　　| Jouets et ours | Rabbit bean bag toy | 3.49 |
　　| Bear Emporium | 8 inch teddy bear | 5.99 |
　　| Bears R Us | 8 inch teddy bear | 5.99 |
　　| Doll House Inc. | 8 inch teddy bear | 5.99 |
　　| Fun and Games | 8 inch teddy bear | 5.99 |
　　| Furball Inc. | 8 inch teddy bear | 5.99 |
　　| Jouets et ours | 8 inch teddy bear | 5.99 |
　　| Bear Emporium | 12 inch teddy bear | 8.99 |
　　| Bears R Us | 12 inch teddy bear | 8.99 |
　　| Doll House Inc. | 12 inch teddy bear | 8.99 |
　　| Fun and Games | 12 inch teddy bear | 8.99 |
　　| Furball Inc. | 12 inch teddy bear | 8.99 |
　　| Jouets et ours | 12 inch teddy bear | 8.99 |
　　| Bear Emporium | 18 inch teddy bear | 11.99 |
　　| Bears R Us | 18 inch teddy bear | 11.99 |
　　| Doll House Inc. | 18 inch teddy bear | 11.99 |
　　| Fun and Games | 18 inch teddy bear | 11.99 |
　　| Furball Inc. | 18 inch teddy bear | 11.99 |
　　| Jouets et ours | 18 inch teddy bear | 11.99 |
　　| Bear Emporium | Raggedy Ann | 4.99 |
　　| Bears R Us | Raggedy Ann | 4.99 |
　　| Doll House Inc. | Raggedy Ann | 4.99 |
　　| Fun and Games | Raggedy Ann | 4.99 |
　　| Furball Inc. | Raggedy Ann | 4.99 |
　　| Jouets et ours | Raggedy Ann | 4.99 |
　　| Bear Emporium | King doll | 9.49 |
　　| Bears R Us | King doll | 9.49 |
　　| Doll House Inc. | King doll | 9.49 |
　　| Fun and Games | King doll | 9.49 |
　　| Furball Inc. | King doll | 9.49 |
　　| Jouets et ours | King doll | 9.49 |
　　| Bear Emporium | Queen doll | 9.49 |
　　| Bears R Us | Queen doll | 9.49 |
　　| Doll House Inc. | Queen doll | 9.49 |
　　| Fun and Games | Queen doll | 9.49 |
　　| Furball Inc. | Queen doll | 9.49 |
　　| Jouets et ours | Queen doll | 9.49 |
　　+-----------------+---------------------+------------+
　　54 rows in set (0.00 sec)
　　其中，vendors有6行，products有9行。
　　注意：应该保证所有的联结都有WHERE子句。
　　12.2.2 内部联结
　　目前为止所用的联结称为等值联结（equi-join），它基于两个表之间的相等测试。这种联结也称为内部联结。其实，对于这种联结可以使用稍微不同的语法来明确指定联结的类型。
　　mysql> select vend_name, prod_name, prod_price
　　 -> from vendors INNER JOIN products
　　 -> ON vendors.vend_id = products.vend_id;
　　“正确的”语法——ANSI SQL规范首选INNER JOIN语法。
　　12.2.3 联结多个表
　　多做实验——
　　第13章创建高级联结
　　13.1 使用表别名
　　mysql> select vend_name, prod_name, prod_price
　　 -> from vendors v, products p
　　 -> where v.vend_id = p.vend_id;
　　+-----------------+---------------------+------------+
　　| vend_name | prod_name | prod_price |
　　+-----------------+---------------------+------------+
　　| Bears R Us | 8 inch teddy bear | 5.99 |
　　| Bears R Us | 12 inch teddy bear | 8.99 |
　　| Bears R Us | 18 inch teddy bear | 11.99 |
　　| Doll House Inc. | Fish bean bag toy | 3.49 |
　　| Doll House Inc. | Bird bean bag toy | 3.49 |
　　| Doll House Inc. | Rabbit bean bag toy | 3.49 |
　　| Doll House Inc. | Raggedy Ann | 4.99 |
　　| Fun and Games | King doll | 9.49 |
　　| Fun and Games | Queen doll | 9.49 |
　　+-----------------+---------------------+------------+
　　9 rows in set (0.00 sec)
　　注意：Oracle不支持AS关键词。
　　13.2 使用不同类型的联结
　　到现在为止，我们使用的只是成为内部联结或等值联结的简单联结。下面来看3中其他联结：自联结、自然联结、外联结。
　　13.2.1 自联结
　　略
　　13.2.2 自然联结
　　自然联结：是每个列只返回一次，排除多次出现的列。怎样完成这项工作呢？答案是，系统不完成这项工作，由你自己完成。这一般是对表使用通配符（select *），对所有其他表的列使用明确的子集完成的。
　　例子略
　　13.2.3 外部联结
　　目前为止所用的联结称为等值联结（equi-join），它基于两个表之间的相等测试。这种联结也称为内部联结。
　　mysql> select vend_name, prod_name, prod_price
　　 -> from vendors INNER JOIN products
　　 -> ON vendors.vend_id = products.vend_id;
　　+-----------------+---------------------+------------+
　　| vend_name | prod_name | prod_price |
　　+-----------------+---------------------+------------+
　　| Bears R Us | 8 inch teddy bear | 5.99 |
　　| Bears R Us | 12 inch teddy bear | 8.99 |
　　| Bears R Us | 18 inch teddy bear | 11.99 |
　　| Doll House Inc. | Fish bean bag toy | 3.49 |
　　| Doll House Inc. | Bird bean bag toy | 3.49 |
　　| Doll House Inc. | Rabbit bean bag toy | 3.49 |
　　| Doll House Inc. | Raggedy Ann | 4.99 |
　　| Fun and Games | King doll | 9.49 |
　　| Fun and Games | Queen doll | 9.49 |
　　+-----------------+---------------------+------------+
　　9 rows in set (0.03 sec)
　　
　　与内部联结不同，外部联结包括没有关联的行。下面的例子，LEFT OUTER JOIN选择from子句左边表的所有行。（即，列出所有供货商及其产品，包括没有提供产品的供货商，下面一节——13.3 使用带聚集函数的联结中的例子更直接，更好理解。）
　　mysql> select vend_name, prod_name, prod_price
　　 -> from vendors LEFT OUTER JOIN products
　　 -> ON vendors.vend_id = products.vend_id;
　　+-----------------+---------------------+------------+
　　| vend_name | prod_name | prod_price |
　　+-----------------+---------------------+------------+
　　| Bear Emporium | NULL | NULL |
　　| Bears R Us | 8 inch teddy bear | 5.99 |
　　| Bears R Us | 12 inch teddy bear | 8.99 |
　　| Bears R Us | 18 inch teddy bear | 11.99 |
　　| Doll House Inc. | Fish bean bag toy | 3.49 |
　　| Doll House Inc. | Bird bean bag toy | 3.49 |
　　| Doll House Inc. | Rabbit bean bag toy | 3.49 |
　　| Doll House Inc. | Raggedy Ann | 4.99 |
　　| Fun and Games | King doll | 9.49 |
　　| Fun and Games | Queen doll | 9.49 |
　　| Furball Inc. | NULL | NULL |
　　| Jouets et ours | NULL | NULL |
　　+-----------------+---------------------+------------+
　　12 rows in set (0.00 sec)
　　13.3 使用带聚集函数的联结
　　对供货商的产品进行计数
　　mysql> select vend_name, count(prod_name)
　　 -> from vendors INNER JOIN products
　　 -> ON vendors.vend_id = products.vend_id
　　 -> group by vend_name;
　　+-----------------+------------------+
　　| vend_name | count(prod_name) |
　　+-----------------+------------------+
　　| Bears R Us | 3 |
　　| Doll House Inc. | 4 |
　　| Fun and Games | 2 |
　　+-----------------+------------------+
　　3 rows in set (0.00 sec)
　　
　　对供货商的产品进行计数，包括没有提供产品的供货商。
　　mysql> select vend_name, count(prod_name)
　　 -> from vendors LEFT OUTER JOIN products
　　 -> ON vendors.ven
关键还是动手自己写啊！！！！
入门知识，简单扼要。
sql语言入门书
赶紧出第4版，把MySQL的新的支持的都加上咯~~
小册子，基础。
　　这本书买来两个礼拜，认真地把我懂得的部分看完了，不懂得的部分还在努力在看……
　　总体来说，这本书很适合入门。
书名又不是关系型数据库原理，会介绍原理和设计才怪了
入门书吧
快速唤起对sql的记忆
好书。逻辑清楚，可读性高
两个晚上读完，数据库实用入门神书。
只读查询语法，讲的还算清楚
　　知道这本书是从一个推荐里看到的，觉得很不错，仔细的看了一遍。
　　可惜我觉得我要学SQL还是一个漫长的过程。
　　忽然想，大学那会儿真该学IT的。。。。
声明性语言--语法顺序和执行顺序不同；select操作是映射；主要的数据类型是表；join操作是集合代数；
书名必知必会么，写给所有杰出SQL数据库人看的，显然不可能有高深的内容
　　以前由于工作的缘故，要经常使用SQL语言去操作数据库，很多东西记不住，或者记忆很模糊，查查这本书就可以了，适合入门的数据库操作员，不错的工具手册。
真的是超级小巧的一本书，作为入门读物甚好（恶补SQL中……QAQ
　　记得是从候清荣那里借阅的，通过这本书可以轻松全面地掌握最常用的SQL，配套了示例脚本可以练习。通过本书可以快速入门。对我第一次找工作起了很大的作用。到甲方做项目经理三年了，别说程序，现在sql都写得很少了，准备再邮购一本，抽空温习一下。
迅速掌握常见SQL语法很有用，很薄的一本书
蛮浅显的，适合入门
简单粗暴。。
简单实用，确实都是些必知必会的东西。
搜SQ居然把它搜出来了
如果希望了解数据库的原理和设计，个人推荐《SQL权威指南》http://book.douban.com/subject/20395440/
　　《SQL必知必会(第3版)》刚买来的时候就非常惊讶--居然这一200页不到的小本本定的市场价是29元，32开的handbook可方便随身带，买来后一口气就阅读到了第七章，大呼过瘾。里面的内容是以前知道但没有理解，但没有像这本书这么教得通俗易懂的，如形容数据表就像是一个文件夹，数据库实例就像是一个文件柜这样容易理解。
　　
　　这本书的原作者写得不错，翻译的水平也极佳。这本书的定位是入门，所以一切都以点到就为止了。比如存储过程那一章原作者就说了只以简单的讲一讲。我们平时实际工作中写得就复杂多了。而且原作者把各种主流DBMS的区别与一般常见的实践技巧全部传授给了你，我们这样的 SQL 菜鸟不正需要这些知识吗？
精炼实用，快速上手
比较好的面试佛脚书吧
对于有过sas中sql使用基础的来说略简单
看完这本，再去hackerrank把数据库的oj刷了，数据库的基础就妥了
2014-11-28 第一次. 为下学期的CS 186做准备
一点也不枯燥的入门书。
浅显易懂, 入门好书
　　花了两个下午读完了这本书，感觉内容比较浅，没有什么太深奥和太思想的东西。当工具书感觉有些介绍的还不是很全，不过感觉初学SQL的可以读读，易读性比较高，另外介绍的东西也都是很基础的知识，感觉觉的不太重要，但是不懂还不行，就是一盘清口的小菜，虽然吃不饱，但吃完会让你吃正餐的时候更舒服。
　　名副其实，书中的内容的确是关系型数据库使用者“必须知道必须会”的，如果你连这些都不知道，那就太……
　　这本书讲得实在有够浅，只适合彻底的新手和入门者。而对于一个有SQL使用经验的人来说，本书前17章和20、22章的内容你一定了如指掌；如果你对18、 19、21章讲解的视图、存储过程和游标功能很陌生，那么你一定和我一样是古老的MySQL4.0的使用者——这个版本不支持这三种功能。
　　如果你是新手的话，这本书还是值得一买的，内容浅显易懂，能帮你很快入门，薄薄一本小册子读起来也很快（原书名直译过来是“SQL 10分钟入门”）。
　　如果你已经使用SQL有一段时间了，那么，还是去寻找更高阶的教程吧。
写的很棒！从头到尾练习2遍以后可以基础入门。0基础一看就会的工具书。强推！
重拾SQL
第一本看完的技术书马克一下通俗易懂
简短的sql语言入门和速查手册

SQL 必知必会（第3版）

发布书评

精彩书评 (总计12条)

精彩短评 (总计67条)

类似图书

相关图书推荐