SQL 自学笔记
DML 和 DDL
可以把 SQL 分为两个部分:数据操作语言(DML) 和 数据定义语言 (DDL)。
SQL (结构化查询语言)是用于执行查询的语法。但是 SQL 语言也包含用于更新、插入和删除记录的语法。
查询和更新指令构成了 SQL 的 DML 部分:
- SELECT - 从数据库表中获取数据
- UPDATE - 更新数据库表中的数据
- DELETE - 从数据库表中删除数据
- INSERT INTO - 向数据库表中插入数据
SQL 的数据定义(DDL) 语言 部分使我们有能力创建或删除表格。我们也可以定义索引(键),规定表之间的链接,以及施加表间的约束。
SQL 中最重要的 DDL 语句:
- CREATE DATABASE - 创建新数据库
- ALTER DATABASE - 修改数据库
- CREATE TABLE - 创建新表
- ALTER TABLE - 变更(改变)数据库表
- DROP TABLE - 删除表
- CREATE INDEX - 创建索引(搜索键)
- DROP INDEX - 删除索引
更新某一行中的若干列
我们会修改地址(address),并添加城市名称(city):
UPDATE Person SET Address = 'Zhongshan 23', City= 'Nanjing'
WHERE LastName = 'Wilson'
TOP 子句
TOP子句用于规定要返回的记录的数目。
对于拥有数千条记录的大型表来说,TOP子句是非常有用的。
注释:并非所有的数据库系统都支持TOP 子句。
SQL Server 的语法:
SELECT TOP number|perc
ent column_name(s)
FROM table_name
SQL TOP PERCENT 实例
现在,我们希望从上面的 "Persons"表中选取 50% 的记录。
我们可以使用下面的 SELECT 语句:
SELECT TOP 50 PERCENT * FROM Persons
SELECT DISTINCT 语句。
SQL SELECT DISTINCT 语句
在表中,可能会包含重复值。这并不成问题,不过,有时您也许希望仅仅列出不同(distinct)的值。
关键词DISTINCT 用于返回唯一不同的值。
语法:
SELECT DISTINCT 列名称 FROM 表名称
使用 DISTINCT 关键词
如果要从 "Company" 列中选取所有的值,我们需要使用 SELECT 语句:
SELECT Company FROM Orders
"Orders"表:
Company | OrderNumber |
IBM | 3532 |
W3School | 2356 |
Apple | 4698 |
W3School | 6953 |
结果:
Company |
IBM |
W3School |
Apple |
W3School |
请注意,在结果集中,W3School 被列出了两次。
如需从 Company" 列中仅选取唯一不同的值,我们需要使用 SELECTDISTINCT 语句:
SELECT DISTINCT Company FROM Orders
结果:
Company |
IBM |
W3School |
Apple |
WHERE 子句用于规定选择的标准。
WHERE 子句
如需有条件地从表中选取数据,可将WHERE 子句添加到 SELECT 语句。
语法
SELECT 列名称 FROM 表名称 WHERE 列 运算符值
下面的运算符可在 WHERE子句中使用:
操作符 | 描述 |
= | 等于 |
<> | 不等于 |
> | 大于 |
< | 小于 |
>= | 大于等于 |
<= | 小于等于 |
BETWEEN | 在某个范围内 |
LIKE | 搜索某种模式 |
注释:在某些版本的 SQL 中,操作符 <> 可以写为 !=。
使用 WHERE 子句
如果只希望选取居住在城市 "Beijing" 中的人,我们需要向 SELECT语句添加 WHERE 子句:
SELECT * FROM Persons WHERE City='Beijing'
"Persons" 表
LastName | FirstName | Address | City | Year |
Adams | John | Oxford Street | London | 1970 |
Bush | George | Fifth Avenue | New York | 1975 |
Carter | Thomas | Changan Street | Beijing | 1980 |
Gates | Bill | Xuanwumen 10 | Beijing | 1985 |
结果:
LastName | FirstName | Address | City | Year |
Carter | Thomas | Changan Street | Beijing | 1980 |
Gates | Bill | Xuanwumen 10 | Beijing | 1985 |
引号的使用
请注意,我们在例子中的条件值周围使用的是单引号。
SQL 使用单引号来环绕文本值(大部分数据库系统也接受双引号)。如果是数值,请不要使用引号。
文本值:
这是正确的:
SELECT * FROM Persons WHERE FirstName='Bush'
这是错误的:
SELECT * FROM Persons WHERE FirstName=Bush
数值:
这是正确的:
SELECT * FROM Persons WHERE Year>1965
这是错误的:
SELECT * FROM Persons WHERE Year>'1965'
AND 和 OR运算符用于基于一个以上的条件对记录进行过滤。
AND 和 OR 运算符
AND 和 OR 可在WHERE 子语句中把两个或多个条件结合起来。
如果第一个条件和第二个条件都成立,则AND 运算符显示一条记录。
如果第一个条件和第二个条件中只要有一个成立,则OR 运算符显示一条记录。
原始的表 (用在例子中的):
LastName | FirstName | Address | City |
Adams | John | Oxford Street | London |
Bush | George | Fifth Avenue | New York |
Carter | Thomas | Changan Street | Beijing |
Carter | William | Xuanwumen 10 | Beijing |
AND 运算符实例
使用 AND 来显示所有姓为"Carter" 并且名为 "Thomas" 的人:
SELECT * FROM Persons WHEREFirstName='Thomas' AND LastName='Carter'
结果:
LastName | FirstName | Address | City |
Carter | Thomas | Changan Street | Beijing |
OR 运算符实例
使用 OR 来显示所有姓为"Carter" 或者名为 "Thomas" 的人:
SELECT * FROM Persons WHEREfirstname='Thomas' OR lastname='Carter'
结果:
LastName | FirstName | Address | City |
Carter | Thomas | Changan Street | Beijing |
Carter | William | Xuanwumen 10 | Beijing |
结合 AND 和 OR 运算符
我们也可以把 AND 和 OR结合起来(使用圆括号来组成复杂的表达式):
SELECT * FROM Persons WHERE (FirstName='Thomas' ORFirstName='William')
AND LastName='Carter'
结果:
LastName | FirstName | Address | City |
Carter | Thomas | Changan Street | Beijing |
Carter | William | Xuanwumen 10 | Beijing |
ORDER BY语句用于对结果集进行排序。
ORDER BY 语句
ORDER BY语句用于根据指定的列对结果集进行排序。
ORDER BY语句默认按照升序对记录进行排序。
如果您希望按照降序对记录进行排序,可以使用DESC 关键字。
原始的表 (用在例子中的):
Orders 表:
Company | OrderNumber |
IBM | 3532 |
W3School | 2356 |
Apple | 4698 |
W3School | 6953 |
实例 1
以字母顺序显示公司名称:
SELECT Company, OrderNumber FROMOrders ORDER BYCompany
结果:
Company | OrderNumber |
Apple | 4698 |
IBM | 3532 |
W3School | 6953 |
W3School | 2356 |
实例 2
以字母顺序显示公司名称(Company),并以数字顺序显示顺序号(OrderNumber):
SELECT Company, OrderNumber FROMOrders ORDER BYCompany, OrderNumber
结果:
Company | OrderNumber |
Apple | 4698 |
IBM | 3532 |
W3School | 2356 |
W3School | 6953 |
实例 3
以逆字母顺序显示公司名称:
SELECT Company, OrderNumber FROMOrders ORDER BYCompany DESC
结果:
Company | OrderNumber |
W3School | 6953 |
W3School | 2356 |
IBM | 3532 |
Apple | 4698 |
实例 4
以逆字母顺序显示公司名称,并以数字顺序显示顺序号:
SELECT Company, OrderNumber FROMOrders ORDER BYCompany DESC, OrderNumber ASC
结果:
Company | OrderNumber |
W3School | 2356 |
W3School | 6953 |
IBM | 3532 |
Apple | 4698 |
注意:在以上的结果中有两个相等的公司名称(W3School)。只有这一次,在第一列中有相同的值时,第二列是以升序排列的。如果第一列中有些值为 nulls 时,情况也是这样的。
INSERT INTO 语句
INSERT INTO 语句用于向表格中插入新的行。
语法
INSERT INTO 表名称 VALUES (值1, 值2,....)
我们也可以指定所要插入数据的列:
INSERT INTO table_name (列1, 列2,...) VALUES (值1, 值2,....)
插入新的行
"Persons"表:
LastName | FirstName | Address | City |
Carter | Thomas | Changan Street | Beijing |
SQL语句:
INSERT INTO Persons VALUES ('Gates', 'Bill','Xuanwumen 10', 'Beijing')
结果:
LastName | FirstName | Address | City |
Carter | Thomas | Changan Street | Beijing |
Gates | Bill | Xuanwumen 10 | Beijing |
在指定的列中插入数据
"Persons"表:
LastName | FirstName | Address | City |
Carter | Thomas | Changan Street | Beijing |
Gates | Bill | Xuanwumen 10 | Beijing |
SQL语句:
INSERT INTO Persons (LastName, Address) VALUES('Wilson', 'Champs-Elysees')
结果:
LastName | FirstName | Address | City |
Carter | Thomas | Changan Street | Beijing |
Gates | Bill | Xuanwumen 10 | Beijing |
Wilson |
| Champs-Elysees |
|
Update 语句
Update 语句用于修改表中的数据。
语法:
UPDATE 表名称 SET 列名称= 新值 WHERE 列名称 = 某值
Person:
LastName | FirstName | Address | City |
Gates | Bill | Xuanwumen 10 | Beijing |
Wilson |
| Champs-Elysees |
|
更新某一行中的一个列
我们为 lastname 是"Wilson" 的人添加 firstname:
UPDATE Person SET FirstName = 'Fred' WHERELastName = 'Wilson'
结果:
LastName | FirstName | Address | City |
Gates | Bill | Xuanwumen 10 | Beijing |
Wilson | Fred | Champs-Elysees |
|
更新某一行中的若干列
我们会修改地址(address),并添加城市名称(city):
UPDATE Person SET Address = 'Zhongshan 23', City= 'Nanjing'
WHERE LastName = 'Wilson'
结果:
LastName | FirstName | Address | City |
Gates | Bill | Xuanwumen 10 | Beijing |
Wilson | Fred | Zhongshan 23 | Nanjing |
DELETE 语句
DELETE 语句用于删除表中的行。
语法
DELETE FROM 表名称 WHERE 列名称 = 值
Person:
LastName | FirstName | Address | City |
Gates | Bill | Xuanwumen 10 | Beijing |
Wilson | Fred | Zhongshan 23 | Nanjing |
删除某行
"FredWilson" 会被删除:
DELETE FROM Person WHERE LastName = 'Wilson'
结果:
LastName | FirstName | Address | City |
Gates | Bill | Xuanwumen 10 | Beijing |
删除所有行
可以在不删除表的情况下删除所有的行。这意味着表的结构、属性和索引都是完整的:
DELETE FROM table_name
或者:
DELETE * FROM table_name
TOP 子句
TOP 子句用于规定要返回的记录的数目。
对于拥有数千条记录的大型表来说,TOP 子句是非常有用的。
注释:并非所有的数据库系统都支持 TOP 子句。
SQL Server 的语法:
SELECT TOP number|percentcolumn_name(s)
FROM table_name
MySQL 和 Oracle 中的 SQL SELECT TOP 是等价的
MySQL语法
SELECT column_name(s)
FROM table_name
LIMIT number
例子
SELECT *
FROM Persons
LIMIT 5
Oracle语法
SELECT column_name(s)
FROM table_name
WHERE ROWNUM <= number
例子
SELECT *
FROM Persons
WHERE ROWNUM <= 5
原始的表 (用在例子中的):
Persons 表:
Id | LastName | FirstName | Address | City |
1 | Adams | John | Oxford Street | London |
2 | Bush | George | Fifth Avenue | New York |
3 | Carter | Thomas | Changan Street | Beijing |
4 | Obama | Barack | Pennsylvania Avenue | Washington |
SQL TOP 实例
现在,我们希望从上面的"Persons" 表中选取头两条记录。
我们可以使用下面的SELECT 语句:
SELECT TOP 2 * FROM Persons
结果:
Id | LastName | FirstName | Address | City |
1 | Adams | John | Oxford Street | London |
2 | Bush | George | Fifth Avenue | New York |
SQL TOP PERCENT 实例
现在,我们希望从上面的"Persons" 表中选取 50% 的记录。
我们可以使用下面的SELECT 语句:
SELECT TOP 50 PERCENT * FROM Persons
结果:
Id | LastName | FirstName | Address | City |
1 | Adams | John | Oxford Street | London |
2 | Bush | George | Fifth Avenue | New York |
LIKE 操作符用于在 WHERE子句中搜索列中的指定模式。
LIKE 操作符
LIKE 操作符用于在WHERE 子句中搜索列中的指定模式。
SQLLIKE 操作符语法
SELECT column_name(s)
FROM table_name
WHERE column_name LIKE pattern
原始的表 (用在例子中的):
Persons 表:
Id | LastName | FirstName | Address | City |
1 | Adams | John | Oxford Street | London |
2 | Bush | George | Fifth Avenue | New York |
3 | Carter | Thomas | Changan Street | Beijing |
LIKE 操作符实例
例子1
现在,我们希望从上面的"Persons" 表中选取居住在以 "N" 开始的城市里的人:
我们可以使用下面的SELECT 语句:
SELECT * FROM Persons
WHERE City LIKE 'N%'
提示:"%"可用于定义通配符(模式中缺少的字母)。
结果集:
Id | LastName | FirstName | Address | City |
2 | Bush | George | Fifth Avenue | New York |
例子2
接下来,我们希望从"Persons" 表中选取居住在以 "g" 结尾的城市里的人:
我们可以使用下面的SELECT 语句:
SELECT * FROM Persons
WHERE City LIKE '%g'
结果集:
Id | LastName | FirstName | Address | City |
3 | Carter | Thomas | Changan Street | Beijing |
例子3
接下来,我们希望从"Persons" 表中选取居住在包含 "lon" 的城市里的人:
我们可以使用下面的SELECT 语句:
SELECT * FROM Persons
WHERE City LIKE '%lon%'
结果集:
Id | LastName | FirstName | Address | City |
1 | Adams | John | Oxford Street | London |
例子4
通过使用 NOT 关键字,我们可以从 "Persons" 表中选取居住在不包含 "lon" 的城市里的人:
我们可以使用下面的SELECT 语句:
SELECT * FROM Persons
WHERE City NOT LIKE '%lon%'
结果集:
Id | LastName | FirstName | Address | City |
2 | Bush | George | Fifth Avenue | New York |
3 | Carter | Thomas | Changan Street | Beijing |
在搜索数据库中的数据时,您可以使用SQL 通配符。
SQL 通配符
在搜索数据库中的数据时,SQL通配符可以替代一个或多个字符。
SQL 通配符必须与 LIKE运算符一起使用。
在 SQL中,可使用以下通配符:
通配符 | 描述 |
% | 替代一个或多个字符 |
_ | 仅替代一个字符 |
[charlist] | 字符列中的任何单一字符 |
[^charlist] 或者 [!charlist] | 不在字符列中的任何单一字符 |
原始的表 (用在例子中的):
Persons 表:
Id | LastName | FirstName | Address | City |
1 | Adams | John | Oxford Street | London |
2 | Bush | George | Fifth Avenue | New York |
3 | Carter | Thomas | Changan Street | Beijing |
使用 % 通配符
例子1
现在,我们希望从上面的"Persons" 表中选取居住在以 "Ne" 开始的城市里的人:
我们可以使用下面的SELECT 语句:
SELECT * FROM Persons
WHERE City LIKE 'Ne%'
结果集:
Id | LastName | FirstName | Address | City |
2 | Bush | George | Fifth Avenue | New York |
例子2
接下来,我们希望从"Persons" 表中选取居住在包含 "lond" 的城市里的人:
我们可以使用下面的SELECT 语句:
SELECT * FROM Persons
WHERE City LIKE '%lond%'
结果集:
Id | LastName | FirstName | Address | City |
1 | Adams | John | Oxford Street | London |
使用 _ 通配符
例子1
现在,我们希望从上面的"Persons" 表中选取名字的第一个字符之后是 "eorge" 的人:
我们可以使用下面的SELECT 语句:
SELECT * FROM Persons
WHERE FirstName LIKE '_eorge'
结果集:
Id | LastName | FirstName | Address | City |
2 | Bush | George | Fifth Avenue | New York |
例子2
接下来,我们希望从"Persons" 表中选取的这条记录的姓氏以 "C" 开头,然后是一个任意字符,然后是"r",然后是任意字符,然后是 "er":
我们可以使用下面的SELECT 语句:
SELECT * FROM Persons
WHERE LastName LIKE 'C_r_er'
结果集:
Id | LastName | FirstName | Address | City |
3 | Carter | Thomas | Changan Street | Beijing |
使用 [charlist] 通配符
例子1
现在,我们希望从上面的"Persons" 表中选取居住的城市以 "A" 或 "L" 或 "N"开头的人:
我们可以使用下面的SELECT 语句:
SELECT * FROM Persons
WHERE City LIKE '[ALN]%'
结果集:
Id | LastName | FirstName | Address | City |
1 | Adams | John | Oxford Street | London |
2 | Bush | George | Fifth Avenue | New York |
例子2
现在,我们希望从上面的 "Persons" 表中选取居住的城市不以 "A" 或"L" 或 "N" 开头的人:
我们可以使用下面的SELECT 语句:
SELECT * FROM Persons
WHERE City LIKE '[!ALN]%'
结果集:
Id | LastName | FirstName | Address | City |
3 | Carter | Thomas | Changan Street | Beijing |
IN 操作符
IN 操作符允许我们在 WHERE 子句中规定多个值。
SQL IN 语法
SELECT column_name(s)
FROM table_name
WHERE column_name IN (value1,value2,...)
原始的表 (在实例中使用:)
Persons 表:
Id | LastName | FirstName | Address | City |
1 | Adams | John | Oxford Street | London |
2 | Bush | George | Fifth Avenue | New York |
3 | Carter | Thomas | Changan Street | Beijing |
IN 操作符实例
现在,我们希望从上表中选取姓氏为Adams 和 Carter 的人:
我们可以使用下面的SELECT 语句:
SELECT * FROM Persons
WHERE LastName IN ('Adams','Carter')
结果集:
Id | LastName | FirstName | Address | City |
1 | Adams | John | Oxford Street | London |
3 | Carter | Thomas | Changan Street | Beijing |
BETWEEN 操作符在WHERE 子句中使用,作用是选取介于两个值之间的数据范围。
BETWEEN 操作符
操作符 BETWEEN ...AND 会选取介于两个值之间的数据范围。这些值可以是数值、文本或者日期。
SQLBETWEEN 语法
SELECT column_name(s)
FROM table_name
WHERE column_name
BETWEEN value1 AND value2
原始的表 (在实例中使用:)
Persons 表:
Id | LastName | FirstName | Address | City |
1 | Adams | John | Oxford Street | London |
2 | Bush | George | Fifth Avenue | New York |
3 | Carter | Thomas | Changan Street | Beijing |
4 | Gates | Bill | Xuanwumen 10 | Beijing |
BETWEEN 操作符实例
如需以字母顺序显示介于"Adams"(包括)和 "Carter"(不包括)之间的人,请使用下面的 SQL:
SELECT * FROM Persons
WHERE LastName
BETWEEN 'Adams' AND 'Carter'
结果集:
Id | LastName | FirstName | Address | City |
1 | Adams | John | Oxford Street | London |
2 | Bush | George | Fifth Avenue | New York |
重要事项:不同的数据库对 BETWEEN...AND操作符的处理方式是有差异的。某些数据库会列出介于 "Adams" 和 "Carter" 之间的人,但不包括"Adams" 和 "Carter" ;某些数据库会列出介于 "Adams" 和"Carter" 之间并包括 "Adams" 和 "Carter" 的人;而另一些数据库会列出介于"Adams" 和 "Carter" 之间的人,包括 "Adams" ,但不包括"Carter" 。
所以,请检查你的数据库是如何处理BETWEEN....AND 操作符的!
实例 2
如需使用上面的例子显示范围之外的人,请使用NOT 操作符:
SELECT * FROM Persons
WHERE LastName
NOT BETWEEN 'Adams' AND 'Carter'
结果集:
Id | LastName | FirstName | Address | City |
3 | Carter | Thomas | Changan Street | Beijing |
4 | Gates | Bill | Xuanwumen 10 | Beijing |
通过使用SQL,可以为列名称和表名称指定别名(Alias)。
SQL Alias
表的SQL Alias 语法
SELECT column_name(s)
FROM table_name
AS alias_name
列的SQL Alias 语法
SELECT column_name AS alias_name
FROM table_name
Alias 实例: 使用表名称别名
假设我们有两个表分别是:"Persons"和 "Product_Orders"。我们分别为它们指定别名 "p" 和 "po"。
现在,我们希望列出"John Adams" 的所有定单。
我们可以使用下面的SELECT 语句:
SELECT po.OrderID, p.LastName,p.FirstName
FROM Persons AS p, Product_Orders AS po
WHERE p.LastName='Adams' AND p.FirstName='John'
不使用别名的 SELECT语句:
SELECT Product_Orders.OrderID, Persons.LastName,Persons.FirstName
FROM Persons, Product_Orders
WHERE Persons.LastName='Adams' AND Persons.FirstName='John'
从上面两条 SELECT语句您可以看到,别名使查询程序更易阅读和书写。
Alias 实例: 使用一个列名别名
表Persons:
Id | LastName | FirstName | Address | City |
1 | Adams | John | Oxford Street | London |
2 | Bush | George | Fifth Avenue | New York |
3 | Carter | Thomas | Changan Street | Beijing |
SQL:
SELECT LastName AS Family, FirstName AS Name
FROM Persons
结果:
Family | Name |
Adams | John |
Bush | George |
Carter | Thomas |
SQL join用于根据两个或多个表中的列之间的关系,从这些表中查询数据。
Join 和 Key
有时为了得到完整的结果,我们需要从两个或更多的表中获取结果。我们就需要执行join。
数据库中的表可通过键将彼此联系起来。主键(PrimaryKey)是一个列,在这个列中的每一行的值都是唯一的。在表中,每个主键的值都是唯一的。这样做的目的是在不重复每个表中的所有数据的情况下,把表间的数据交叉捆绑在一起。
请看"Persons" 表:
Id_P | LastName | FirstName | Address | City |
1 | Adams | John | Oxford Street | London |
2 | Bush | George | Fifth Avenue | New York |
3 | Carter | Thomas | Changan Street | Beijing |
请注意,"Id_P"列是 Persons 表中的的主键。这意味着没有两行能够拥有相同的 Id_P。即使两个人的姓名完全相同,Id_P 也可以区分他们。
接下来请看"Orders" 表:
Id_O | OrderNo | Id_P |
1 | 77895 | 3 |
2 | 44678 | 3 |
3 | 22456 | 1 |
4 | 24562 | 1 |
5 | 34764 | 65 |
请注意,"Id_O"列是 Orders 表中的的主键,同时,"Orders" 表中的 "Id_P" 列用于引用"Persons" 表中的人,而无需使用他们的确切姓名。
请留意,"Id_P"列把上面的两个表联系了起来。
引用两个表
我们可以通过引用两个表的方式,从两个表中获取数据:
谁订购了产品,并且他们订购了什么产品?
SELECT Persons.LastName, Persons.FirstName,Orders.OrderNo
FROM Persons, Orders
WHERE Persons.Id_P = Orders.Id_P
结果集:
LastName | FirstName | OrderNo |
Adams | John | 22456 |
Adams | John | 24562 |
Carter | Thomas | 77895 |
Carter | Thomas | 44678 |
SQL JOIN - 使用 Join
除了上面的方法,我们也可以使用关键词JOIN 来从两个表中获取数据。
如果我们希望列出所有人的定购,可以使用下面的SELECT 语句:
SELECT Persons.LastName,Persons.FirstName, Orders.OrderNo
FROM Persons
INNER JOIN Orders
ON Persons.Id_P = Orders.Id_P
ORDER BY Persons.LastName
结果集:
LastName | FirstName | OrderNo |
Adams | John | 22456 |
Adams | John | 24562 |
Carter | Thomas | 77895 |
Carter | Thomas | 44678 |
不同的 SQL JOIN
除了我们在上面的例子中使用的INNER JOIN(内连接),我们还可以使用其他几种连接。
下面列出了您可以使用的JOIN 类型,以及它们之间的差异。
- JOIN: 如果表中有至少一个匹配,则返回行
- LEFT JOIN: 即使右表中没有匹配,也从左表返回所有的行
- RIGHT JOIN: 即使左表中没有匹配,也从右表返回所有的行
- FULL JOIN: 只要其中一个表中存在匹配,就返回行
SQL INNER JOIN 关键字
在表中存在至少一个匹配时,INNER JOIN 关键字返回行。
INNER JOIN 关键字语法
SELECT column_name(s)
FROM table_name1
INNER JOIN table_name2
ON table_name1.column_name=table_name2.column_name
注释:INNER JOIN 与 JOIN 是相同的。
原始的表 (用在例子中的):
"Persons"表:
Id_P | LastName | FirstName | Address | City |
1 | Adams | John | Oxford Street | London |
2 | Bush | George | Fifth Avenue | New York |
3 | Carter | Thomas | Changan Street | Beijing |
"Orders"表:
Id_O | OrderNo | Id_P |
1 | 77895 | 3 |
2 | 44678 | 3 |
3 | 22456 | 1 |
4 | 24562 | 1 |
5 | 34764 | 65 |
内连接(INNER JOIN)实例
现在,我们希望列出所有人的定购。
您可以使用下面的 SELECT语句:
SELECT Persons.LastName, Persons.FirstName,Orders.OrderNo
FROM Persons
INNER JOIN Orders
ON Persons.Id_P=Orders.Id_P
ORDER BY Persons.LastName
结果集:
LastName | FirstName | OrderNo |
Adams | John | 22456 |
Adams | John | 24562 |
Carter | Thomas | 77895 |
Carter | Thomas | 44678 |
INNER JOIN关键字在表中存在至少一个匹配时返回行。如果 "Persons" 中的行在 "Orders"中没有匹配,就不会列出这些行。
SQL LEFT JOIN 关键字
LEFT JOIN 关键字会从左表 (table_name1) 那里返回所有的行,即使在右表(table_name2) 中没有匹配的行。
LEFT JOIN 关键字语法
SELECT column_name(s)
FROM table_name1
LEFT JOIN table_name2
ON table_name1.column_name=table_name2.column_name
注释:在某些数据库中, LEFT JOIN 称为 LEFT OUTER JOIN。
原始的表 (用在例子中的):
"Persons"表:
Id_P | LastName | FirstName | Address | City |
1 | Adams | John | Oxford Street | London |
2 | Bush | George | Fifth Avenue | New York |
3 | Carter | Thomas | Changan Street | Beijing |
"Orders"表:
Id_O | OrderNo | Id_P |
1 | 77895 | 3 |
2 | 44678 | 3 |
3 | 22456 | 1 |
4 | 24562 | 1 |
5 | 34764 | 65 |
左连接(LEFT JOIN)实例
现在,我们希望列出所有的人,以及他们的定购- 如果有的话。
您可以使用下面的 SELECT语句:
SELECT Persons.LastName, Persons.FirstName,Orders.OrderNo
FROM Persons
LEFT JOIN Orders
ON Persons.Id_P=Orders.Id_P
ORDER BY Persons.LastName
结果集:
LastName | FirstName | OrderNo |
Adams | John | 22456 |
Adams | John | 24562 |
Carter | Thomas | 77895 |
Carter | Thomas | 44678 |
Bush | George |
|
LEFT JOIN关键字会从左表 (Persons) 那里返回所有的行,即使在右表 (Orders) 中没有匹配的行。
SQL UNION 操作符
UNION 操作符用于合并两个或多个 SELECT 语句的结果集。
请注意,UNION 内部的 SELECT语句必须拥有相同数量的列。列也必须拥有相似的数据类型。同时,每条 SELECT 语句中的列的顺序必须相同。
SQL UNION 语法
SELECT column_name(s) FROMtable_name1
UNION
SELECT column_name(s) FROM table_name2
注释:默认地,UNION 操作符选取不同的值。如果允许重复的值,请使用 UNION ALL。
SQL UNION ALL 语法
SELECT column_name(s) FROM table_name1
UNION ALL
SELECT column_name(s) FROM table_name2
另外,UNION 结果集中的列名总是等于 UNION 中第一个 SELECT 语句中的列名。
下面的例子中使用的原始表:
Employees_China:
E_ID | E_Name |
01 | Zhang, Hua |
02 | Wang, Wei |
03 | Carter, Thomas |
04 | Yang, Ming |
Employees_USA:
E_ID | E_Name |
01 | Adams, John |
02 | Bush, George |
03 | Carter, Thomas |
04 | Gates, Bill |
使用 UNION 命令
实例
列出所有在中国和美国的不同的雇员名:
SELECT E_Name FROMEmployees_China
UNION
SELECT E_Name FROM Employees_USA
结果
E_Name |
Zhang, Hua |
Wang, Wei |
Carter, Thomas |
Yang, Ming |
Adams, John |
Bush, George |
Gates, Bill |
注释:这个命令无法列出在中国和美国的所有雇员。在上面的例子中,我们有两个名字相同的雇员,他们当中只有一个人被列出来了。UNION命令只会选取不同的值。
UNION ALL
UNION ALL 命令和UNION 命令几乎是等效的,不过 UNION ALL 命令会列出所有的值。
SQL Statement 1
UNION ALL
SQL Statement 2
使用 UNION ALL 命令
实例:
列出在中国和美国的所有的雇员:
SELECT E_Name FROMEmployees_China
UNION ALL
SELECT E_Name FROM Employees_USA
结果
E_Name |
Zhang, Hua |
Wang, Wei |
Carter, Thomas |
Yang, Ming |
Adams, John |
Bush, George |
Carter, Thomas |
Gates, Bill |
SQL SELECT INTO语句可用于创建表的备份复件。
SELECT INTO 语句
SELECT INTO语句从一个表中选取数据,然后把数据插入另一个表中。
SELECT INTO语句常用于创建表的备份复件或者用于对记录进行存档。
SQLSELECT INTO 语法
您可以把所有的列插入新表:
SELECT *
INTO new_table_name [IN externaldatabase]
FROM old_tablename
或者只把希望的列插入新表:
SELECT column_name(s)
INTO new_table_name [IN externaldatabase]
FROM old_tablename
SQL SELECT INTO 实例 - 制作备份复件
下面的例子会制作"Persons" 表的备份复件:
SELECT *
INTO Persons_backup
FROM Persons
IN子句可用于向另一个数据库中拷贝表:
SELECT *
INTO Persons IN 'Backup.mdb'
FROM Persons
如果我们希望拷贝某些域,可以在SELECT 语句后列出这些域:
SELECT LastName,FirstName
INTO Persons_backup
FROM Persons
SQL SELECT INTO 实例 - 带有 WHERE 子句
我们也可以添加 WHERE子句。
下面的例子通过从"Persons" 表中提取居住在 "Beijing" 的人的信息,创建了一个带有两个列的名为"Persons_backup" 的表:
SELECT LastName,Firstname
INTO Persons_backup
FROM Persons
WHERE City='Beijing'
SQL SELECT INTO 实例 - 被连接的表
从一个以上的表中选取数据也是可以做到的。
下面的例子会创建一个名为"Persons_Order_Backup" 的新表,其中包含了从 Persons 和 Orders 两个表中取得的信息:
SELECTPersons.LastName,Orders.OrderNo
INTO Persons_Order_Backup
FROM Persons
INNER JOIN Orders
ON Persons.Id_P=Orders.Id_P
CREATE DATABASE 语句
CREATE DATABASE 用于创建数据库。
SQL CREATE DATABASE 语法
CREATE DATABASE database_name
SQL CREATE DATABASE 实例
现在我们希望创建一个名为"my_db" 的数据库。
我们使用下面的 CREATEDATABASE 语句:
CREATE DATABASE my_db
可以通过 CREATETABLE 来添加数据库表。
CREATE TABLE 语句
CREATE TABLE 语句用于创建数据库中的表。
SQL CREATE TABLE 语法
CREATE TABLE 表名称
(
列名称1 数据类型,
列名称2 数据类型,
列名称3 数据类型,
....
)
数据类型(data_type)规定了列可容纳何种数据类型。下面的表格包含了SQL中最常用的数据类型:
数据类型 | 描述 |
| 仅容纳整数。在括号内规定数字的最大位数。 |
| 容纳带有小数的数字。 "size" 规定数字的最大位数。"d" 规定小数点右侧的最大位数。 |
char(size) | 容纳固定长度的字符串(可容纳字母、数字以及特殊字符)。 在括号中规定字符串的长度。 |
varchar(size) | 容纳可变长度的字符串(可容纳字母、数字以及特殊的字符)。 在括号中规定字符串的最大长度。 |
date(yyyymmdd) | 容纳日期。 |
SQL CREATE TABLE 实例
本例演示如何创建名为"Person" 的表。
该表包含 5个列,列名分别是:"Id_P"、"LastName"、"FirstName"、"Address"以及 "City":
CREATE TABLE Persons
(
Id_P int,
LastName varchar(255),
FirstName varchar(255),
Address varchar(255),
City varchar(255)
)
Id_P 列的数据类型是int,包含整数。其余 4 列的数据类型是 varchar,最大长度为 255 个字符。
空的"Persons" 表类似这样:
Id_P | LastName | FirstName | Address | City |
可使用 INSERT INTO语句向空表写入数据。
SQL 约束
约束用于限制加入表的数据的类型。
可以在创建表时规定约束(通过CREATE TABLE 语句),或者在表创建之后也可以(通过 ALTER TABLE 语句)。
我们将主要探讨以下几种约束:
- NOT NULL
- UNIQUE
- PRIMARY KEY
- FOREIGN KEY
- CHECK
- DEFAULT
注释:在下面的章节,我们会详细讲解每一种约束。
SQL NOT NULL 约束
NOTNULL 约束强制列不接受 NULL 值。
NOTNULL 约束强制字段始终包含值。这意味着,如果不向字段添加值,就无法插入新记录或者更新记录。
下面的SQL 语句强制 "Id_P" 列和 "LastName" 列不接受 NULL 值:
CREATE TABLE Persons
(
Id_P int NOT NULL,
LastName varchar(255) NOTNULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255)
)
SQL UNIQUE 约束
UNIQUE 约束唯一标识数据库表中的每条记录。
UNIQUE 和 PRIMARY KEY 约束均为列或列集合提供了唯一性的保证。
PRIMARY KEY 拥有自动定义的 UNIQUE 约束。
请注意,每个表可以有多个 UNIQUE 约束,但是每个表只能有一个 PRIMARY KEY 约束。
SQL UNIQUE Constraint on CREATE TABLE
下面的 SQL 在"Persons" 表创建时在 "Id_P" 列创建 UNIQUE 约束:
MySQL:
CREATE TABLE Persons
(
Id_P int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255),
UNIQUE (Id_P)
)
SQLServer / Oracle / MS Access:
CREATE TABLE Persons
(
Id_P int NOT NULL UNIQUE,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255)
)
如果需要命名 UNIQUE约束,以及为多个列定义 UNIQUE 约束,请使用下面的 SQL 语法:
MySQL/ SQL Server / Oracle / MS Access:
CREATE TABLE Persons
(
Id_P int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255),
CONSTRAINT uc_PersonIDUNIQUE (Id_P,LastName)
)
SQL UNIQUE Constraint on ALTER TABLE
当表已被创建时,如需在"Id_P" 列创建 UNIQUE 约束,请使用下列 SQL:
MySQL/ SQL Server / Oracle / MS Access:
ALTER TABLE Persons
ADD UNIQUE (Id_P)
如需命名 UNIQUE约束,并定义多个列的 UNIQUE 约束,请使用下面的 SQL 语法:
MySQL/ SQL Server / Oracle / MS Access:
ALTER TABLE Persons
ADD CONSTRAINTuc_PersonID UNIQUE (Id_P,LastName)
撤销 UNIQUE 约束
如需撤销 UNIQUE约束,请使用下面的 SQL:
MySQL:
ALTER TABLE Persons
DROP INDEX uc_PersonID
SQLServer / Oracle / MS Access:
ALTER TABLE Persons
DROP CONSTRAINTuc_PersonID
SQL PRIMARY KEY 约束
PRIMARY KEY 约束唯一标识数据库表中的每条记录。
主键必须包含唯一的值。
主键列不能包含 NULL 值。
每个表都应该有一个主键,并且每个表只能有一个主键。
SQL PRIMARY KEY Constraint on CREATE TABLE
下面的 SQL 在"Persons" 表创建时在 "Id_P" 列创建 PRIMARY KEY 约束:
MySQL:
CREATE TABLE Persons
(
Id_P int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255),
PRIMARY KEY (Id_P)
)
SQLServer / Oracle / MS Access:
CREATE TABLE Persons
(
Id_P int NOT NULL PRIMARYKEY,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255)
)
如果需要命名 PRIMARYKEY 约束,以及为多个列定义 PRIMARY KEY 约束,请使用下面的 SQL 语法:
MySQL/ SQL Server / Oracle / MS Access:
CREATE TABLE Persons
(
Id_P int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255),
CONSTRAINT uc_PersonIDPRIMARY KEY (Id_P,LastName)
)
SQL PRIMARY KEY Constraint on ALTER TABLE
如果在表已存在的情况下为"Id_P" 列创建 PRIMARY KEY 约束,请使用下面的 SQL:
MySQL/ SQL Server / Oracle / MS Access:
ALTER TABLE Persons
ADD PRIMARY KEY (Id_P)
如果需要命名 PRIMARYKEY 约束,以及为多个列定义 PRIMARY KEY 约束,请使用下面的 SQL 语法:
MySQL/ SQL Server / Oracle / MS Access:
ALTER TABLE Persons
ADD CONSTRAINTpk_PersonID PRIMARY KEY (Id_P,LastName)
注释:如果您使用 ALTER TABLE 语句添加主键,必须把主键列声明为不包含 NULL值(在表首次创建时)。
撤销 PRIMARY KEY 约束
如需撤销 PRIMARYKEY 约束,请使用下面的 SQL:
MySQL:
ALTER TABLE Persons
DROP PRIMARY KEY
SQLServer / Oracle / MS Access:
ALTER TABLE Persons
DROP CONSTRAINTpk_PersonID
SQL FOREIGN KEY 约束
一个表中的 FOREIGN KEY 指向另一个表中的 PRIMARY KEY。
让我们通过一个例子来解释外键。请看下面两个表:
"Persons" 表:
Id_P | LastName | FirstName | Address | City |
1 | Adams | John | Oxford Street | London |
2 | Bush | George | Fifth Avenue | New York |
3 | Carter | Thomas | Changan Street | Beijing |
"Orders" 表:
Id_O | OrderNo | Id_P |
1 | 77895 | 3 |
2 | 44678 | 3 |
3 | 22456 | 1 |
4 | 24562 | 1 |
请注意,"Orders" 中的 "Id_P" 列指向"Persons" 表中的 "Id_P" 列。
"Persons" 表中的 "Id_P" 列是"Persons" 表中的 PRIMARY KEY。
"Orders" 表中的 "Id_P" 列是"Orders" 表中的 FOREIGN KEY。
FOREIGN KEY 约束用于预防破坏表之间连接的动作。
FOREIGN KEY 约束也能防止非法数据插入外键列,因为它必须是它指向的那个表中的值之一。
SQL FOREIGN KEY Constraint on CREATE TABLE
下面的 SQL 在"Orders" 表创建时为 "Id_P" 列创建 FOREIGN KEY:
MySQL:
CREATE TABLE Orders
(
O_Id int NOT NULL,
OrderNo int NOT NULL,
Id_P int,
PRIMARY KEY (O_Id),
FOREIGN KEY (Id_P)REFERENCES Persons(Id_P)
)
SQLServer / Oracle / MS Access:
CREATE TABLE Orders
(
O_Id int NOT NULL PRIMARY KEY,
OrderNo int NOT NULL,
Id_P int FOREIGN KEYREFERENCES Persons(Id_P)
)
如果需要命名 FOREIGNKEY 约束,以及为多个列定义 FOREIGN KEY 约束,请使用下面的 SQL 语法:
MySQL/ SQL Server / Oracle / MS Access:
CREATE TABLE Orders
(
O_Id int NOT NULL,
OrderNo int NOT NULL,
Id_P int,
PRIMARY KEY (O_Id),
CONSTRAINTfk_PerOrders FOREIGN KEY (Id_P)
REFERENCES Persons(Id_P)
)
SQL FOREIGN KEY Constraint on ALTER TABLE
如果在"Orders" 表已存在的情况下为 "Id_P" 列创建 FOREIGN KEY 约束,请使用下面的 SQL:
MySQL/ SQL Server / Oracle / MS Access:
ALTER TABLE Orders
ADD FOREIGN KEY(Id_P)
REFERENCES Persons(Id_P)
如果需要命名 FOREIGNKEY 约束,以及为多个列定义 FOREIGN KEY 约束,请使用下面的 SQL 语法:
MySQL/ SQL Server / Oracle / MS Access:
ALTER TABLE Orders
ADD CONSTRAINTfk_PerOrders
FOREIGN KEY (Id_P)
REFERENCES Persons(Id_P)
撤销 FOREIGN KEY 约束
如需撤销 FOREIGNKEY 约束,请使用下面的 SQL:
MySQL:
ALTER TABLE Orders
DROP FOREIGN KEYfk_PerOrders
SQLServer / Oracle / MS Access:
ALTER TABLE Orders
DROP CONSTRAINTfk_PerOrders
SQL CHECK 约束
CHECK 约束用于限制列中的值的范围。
如果对单个列定义 CHECK 约束,那么该列只允许特定的值。
如果对一个表定义 CHECK 约束,那么此约束会在特定的列中对值进行限制。
SQL CHECK Constraint on CREATE TABLE
下面的 SQL 在"Persons" 表创建时为 "Id_P" 列创建 CHECK 约束。CHECK 约束规定"Id_P" 列必须只包含大于 0 的整数。
MySQL:
CREATE TABLE Persons
(
Id_P int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255),
CHECK (Id_P>0)
)
SQLServer / Oracle / MS Access:
CREATE TABLE Persons
(
Id_P int NOT NULL CHECK(Id_P>0),
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255)
)
如果需要命名 CHECK约束,以及为多个列定义 CHECK 约束,请使用下面的 SQL 语法:
MySQL/ SQL Server / Oracle / MS Access:
CREATE TABLE Persons
(
Id_P int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255),
CONSTRAINT chk_PersonCHECK (Id_P>0 AND City='Sandnes')
)
SQL CHECK Constraint on ALTER TABLE
如果在表已存在的情况下为"Id_P" 列创建 CHECK 约束,请使用下面的 SQL:
MySQL/ SQL Server / Oracle / MS Access:
ALTER TABLE Persons
ADD CHECK (Id_P>0)
如果需要命名 CHECK约束,以及为多个列定义 CHECK 约束,请使用下面的 SQL 语法:
MySQL/ SQL Server / Oracle / MS Access:
ALTER TABLE Persons
ADD CONSTRAINTchk_Person CHECK (Id_P>0 AND City='Sandnes')
撤销 CHECK 约束
如需撤销 CHECK约束,请使用下面的 SQL:
SQLServer / Oracle / MS Access:
ALTER TABLE Persons
DROP CONSTRAINTchk_Person
MySQL:
ALTER TABLE Persons
DROP CHECK chk_Person
SQL DEFAULT 约束
DEFAULT 约束用于向列中插入默认值。
如果没有规定其他的值,那么会将默认值添加到所有的新记录。
SQL DEFAULT Constraint on CREATE TABLE
下面的 SQL 在"Persons" 表创建时为 "City" 列创建 DEFAULT 约束:
MySQL / SQL Server / Oracle / MS Access:
CREATE TABLE Persons
(
Id_P int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255) DEFAULT 'Sandnes'
)
通过使用类似GETDATE() 这样的函数,DEFAULT 约束也可以用于插入系统值:
CREATE TABLE Orders
(
Id_O int NOT NULL,
OrderNo int NOT NULL,
Id_P int,
OrderDate date DEFAULT GETDATE()
)
SQL DEFAULT Constraint on ALTER TABLE
如果在表已存在的情况下为"City" 列创建 DEFAULT 约束,请使用下面的 SQL:
MySQL:
ALTER TABLE Persons
ALTER City SET DEFAULT 'SANDNES'
SQLServer / Oracle / MS Access:
ALTER TABLE Persons
ALTER COLUMN City SET DEFAULT 'SANDNES'
撤销 DEFAULT 约束
如需撤销 DEFAULT约束,请使用下面的 SQL:
MySQL:
ALTER TABLE Persons
ALTER City DROP DEFAULT
SQLServer / Oracle / MS Access:
ALTER TABLE Persons
ALTER COLUMN City DROP DEFAULT
CREATE INDEX语句用于在表中创建索引。
在不读取整个表的情况下,索引使数据库应用程序可以更快地查找数据。
索引
您可以在表中创建索引,以便更加快速高效地查询数据。
用户无法看到索引,它们只能被用来加速搜索/查询。
注释:更新一个包含索引的表需要比更新一个没有索引的表更多的时间,这是由于索引本身也需要更新。因此,理想的做法是仅仅在常常被搜索的列(以及表)上面创建索引。
SQLCREATE INDEX 语法
在表上创建一个简单的索引。允许使用重复的值:
CREATE INDEX index_name
ON table_name (column_name)
注释:"column_name" 规定需要索引的列。
SQLCREATE UNIQUE INDEX 语法
在表上创建一个唯一的索引。唯一的索引意味着两个行不能拥有相同的索引值。
CREATE UNIQUE INDEX index_name
ON table_name (column_name)
CREATE INDEX 实例
本例会创建一个简单的索引,名为"PersonIndex",在 Person 表的 LastName 列:
CREATE INDEX PersonIndex
ON Person (LastName)
如果您希望以降序索引某个列中的值,您可以在列名称之后添加保留字 DESC:
CREATE INDEX PersonIndex
ON Person (LastName DESC)
假如您希望索引不止一个列,您可以在括号中列出这些列的名称,用逗号隔开:
CREATE INDEX PersonIndex
ON Person (LastName, FirstName)
通过使用 DROP语句,可以轻松地删除索引、表和数据库。
SQL DROP INDEX 语句
我们可以使用 DROPINDEX 命令删除表格中的索引。
用于Microsoft SQLJet (以及 Microsoft Access) 的语法:
DROP INDEX index_name ON table_name
用于MS SQL Server 的语法:
DROP INDEX table_name.index_name
用于IBM DB2 和 Oracle 语法:
DROP INDEX index_name
用于MySQL 的语法:
ALTER TABLE table_name DROP INDEX index_name
SQL DROP TABLE 语句
DROP TABLE语句用于删除表(表的结构、属性以及索引也会被删除):
DROP TABLE 表名称
SQL DROP DATABASE 语句
DROP DATABASE语句用于删除数据库:
DROP DATABASE 数据库名称
SQL TRUNCATE TABLE 语句
如果我们仅仅需要除去表内的数据,但并不删除表本身,那么我们该如何做呢?
请使用 TRUNCATETABLE 命令(仅仅删除表格中的数据):
TRUNCATE TABLE 表名称
ALTER TABLE 语句
ALTER TABLE 语句用于在已有的表中添加、修改或删除列。
SQL ALTER TABLE 语法
如需在表中添加列,请使用下列语法:
ALTER TABLE table_name
ADD column_name datatype
要删除表中的列,请使用下列语法:
ALTER TABLE table_name
DROP COLUMN column_name
注释:某些数据库系统不允许这种在数据库表中删除列的方式 (DROP COLUMN column_name)。
要改变表中列的数据类型,请使用下列语法:
ALTER TABLE table_name
ALTER COLUMN column_name datatype
原始的表 (用在例子中的):
Persons 表:
Id | LastName | FirstName | Address | City |
1 | Adams | John | Oxford Street | London |
2 | Bush | George | Fifth Avenue | New York |
3 | Carter | Thomas | Changan Street | Beijing |
SQL ALTER TABLE 实例
现在,我们希望在表"Persons" 中添加一个名为 "Birthday" 的新列。
我们使用下列 SQL 语句:
ALTER TABLE Persons
ADD Birthday date
请注意,新列"Birthday" 的类型是 date,可以存放日期。数据类型规定列中可以存放的数据的类型。
新的"Persons" 表类似这样:
Id | LastName | FirstName | Address | City | Birthday |
1 | Adams | John | Oxford Street | London |
|
2 | Bush | George | Fifth Avenue | New York |
|
3 | Carter | Thomas | Changan Street | Beijing |
|
改变数据类型实例
现在我们希望改变"Persons" 表中 "Birthday" 列的数据类型。
我们使用下列 SQL 语句:
ALTER TABLE Persons
ALTER COLUMN Birthday year
请注意,"Birthday"列的数据类型是 year,可以存放 2 位或 4 位格式的年份。
DROP COLUMN 实例
接下来,我们删除"Person" 表中的 "Birthday" 列:
ALTER TABLE Person
DROP COLUMN Birthday
Persons 表会成为这样:
Id | LastName | FirstName | Address | City |
1 | Adams | John | Oxford Street | London |
2 | Bush | George | Fifth Avenue | New York |
3 | Carter | Thomas | Changan Street | Beijing |
Auto-increment会在新记录插入表中时生成一个唯一的数字。
AUTO INCREMENT 字段
我们通常希望在每次插入新记录时,自动地创建主键字段的值。
我们可以在表中创建一个auto-increment 字段。
用于 MySQL 的语法
下列 SQL 语句把"Persons" 表中的 "P_Id" 列定义为 auto-increment 主键:
CREATE TABLE Persons
(
P_Id int NOT NULLAUTO_INCREMENT,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255),
PRIMARY KEY (P_Id)
)
MySQL 使用AUTO_INCREMENT 关键字来执行 auto-increment 任务。
默认地,AUTO_INCREMENT的开始值是 1,每条新记录递增 1。
要让AUTO_INCREMENT 序列以其他的值起始,请使用下列 SQL 语法:
ALTER TABLE Persons AUTO_INCREMENT=100
要在"Persons" 表中插入新记录,我们不必为 "P_Id" 列规定值(会自动添加一个唯一的值):
INSERT INTO Persons(FirstName,LastName)
VALUES ('Bill','Gates')
上面的 SQL 语句会在"Persons" 表中插入一条新记录。"P_Id" 会被赋予一个唯一的值。"FirstName"会被设置为 "Bill","LastName" 列会被设置为 "Gates"。
用于 SQL Server 的语法
下列 SQL 语句把"Persons" 表中的 "P_Id" 列定义为 auto-increment 主键:
CREATE TABLE Persons
(
P_Id int PRIMARY KEYIDENTITY,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255)
)
MS SQL 使用IDENTITY 关键字来执行 auto-increment 任务。
默认地,IDENTITY的开始值是 1,每条新记录递增 1。
要规定"P_Id" 列以 20 起始且递增 10,请把 identity 改为 IDENTITY(20,10)
要在"Persons" 表中插入新记录,我们不必为 "P_Id" 列规定值(会自动添加一个唯一的值):
INSERT INTO Persons(FirstName,LastName)
VALUES ('Bill','Gates')
上面的 SQL 语句会在"Persons" 表中插入一条新记录。"P_Id" 会被赋予一个唯一的值。"FirstName"会被设置为 "Bill","LastName" 列会被设置为 "Gates"。
用于 Access 的语法
下列 SQL 语句把"Persons" 表中的 "P_Id" 列定义为 auto-increment 主键:
CREATE TABLE Persons
(
P_Id int PRIMARY KEYAUTOINCREMENT,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255)
)
MS Access 使用AUTOINCREMENT 关键字来执行 auto-increment 任务。
默认地,AUTOINCREMENT的开始值是 1,每条新记录递增 1。
要规定"P_Id" 列以 20 起始且递增 10,请把 autoincrement 改为 AUTOINCREMENT(20,10)
要在"Persons" 表中插入新记录,我们不必为 "P_Id" 列规定值(会自动添加一个唯一的值):
INSERT INTO Persons(FirstName,LastName)
VALUES ('Bill','Gates')
上面的 SQL 语句会在"Persons" 表中插入一条新记录。"P_Id" 会被赋予一个唯一的值。"FirstName"会被设置为 "Bill","LastName" 列会被设置为 "Gates"。
用于 Oracle 的语法
在 Oracle中,代码稍微复杂一点。
您必须通过 sequence对创建 auto-increment 字段(该对象生成数字序列)。
请使用下面的 CREATESEQUENCE 语法:
CREATE SEQUENCE seq_person
MINVALUE 1
START WITH 1
INCREMENT BY 1
CACHE 10
上面的代码创建名为seq_person 的序列对象,它以 1 起始且以 1 递增。该对象缓存 10 个值以提高性能。CACHE 选项规定了为了提高访问速度要存储多少个序列值。
要在"Persons" 表中插入新记录,我们必须使用 nextval 函数(该函数从 seq_person 序列中取回下一个值):
INSERT INTO Persons(P_Id,FirstName,LastName)
VALUES (seq_person.nextval,'Lars','Monsen')
上面的 SQL 语句会在"Persons" 表中插入一条新记录。"P_Id" 的赋值是来自 seq_person序列的下一个数字。"FirstName" 会被设置为 "Bill","LastName"列会被设置为 "Gates"。
视图是可视化的表。
本章讲解如何创建、更新和删除视图。
SQL CREATE VIEW 语句
什么是视图?
在 SQL 中,视图是基于SQL 语句的结果集的可视化的表。
视图包含行和列,就像一个真实的表。视图中的字段就是来自一个或多个数据库中的真实的表中的字段。我们可以向视图添加SQL 函数、WHERE 以及 JOIN 语句,我们也可以提交数据,就像这些来自于某个单一的表。
注释:数据库的设计和结构不会受到视图中的函数、where 或 join 语句的影响。
SQLCREATE VIEW 语法
CREATE VIEW view_name AS
SELECT column_name(s)
FROM table_name
WHERE condition
注释:视图总是显示最近的数据。每当用户查询视图时,数据库引擎通过使用 SQL 语句来重建数据。
SQL CREATE VIEW 实例
可以从某个查询内部、某个存储过程内部,或者从另一个视图内部来使用视图。通过向视图添加函数、join等等,我们可以向用户精确地提交我们希望提交的数据。
样本数据库 Northwind拥有一些被默认安装的视图。视图 "Current Product List" 会从 Products表列出所有正在使用的产品。这个视图使用下列 SQL 创建:
CREATE VIEW [Current Product List] AS
SELECT ProductID,ProductName
FROM Products
WHERE Discontinued=No
我们可以查询上面这个视图:
SELECT * FROM [Current Product List]
Northwind样本数据库的另一个视图会选取 Products 表中所有单位价格高于平均单位价格的产品:
CREATE VIEW [Products Above Average Price] AS
SELECT ProductName,UnitPrice
FROM Products
WHERE UnitPrice>(SELECT AVG(UnitPrice)FROM Products)
我们可以像这样查询上面这个视图:
SELECT * FROM [Products Above Average Price]
另一个来自 Northwind数据库的视图实例会计算在 1997 年每个种类的销售总数。请注意,这个视图会从另一个名为 "Product Sales for 1997"的视图那里选取数据:
CREATE VIEW [Category Sales For 1997] AS
SELECT DISTINCT CategoryName,Sum(ProductSales) AS CategorySales
FROM [Product Sales for 1997]
GROUP BY CategoryName
我们可以像这样查询上面这个视图:
SELECT * FROM [Category Sales For 1997]
我们也可以向查询添加条件。现在,我们仅仅需要查看"Beverages" 类的全部销量:
SELECT * FROM[Category Sales For 1997]
WHERE CategoryName='Beverages'
SQL 更新视图
您可以使用下面的语法来更新视图:
SQL CREATE OR REPLACE VIEW Syntax
CREATE OR REPLACE VIEW view_name AS
SELECT column_name(s)
FROM table_name
WHERE condition
现在,我们希望向"Current Product List" 视图添加 "Category" 列。我们将通过下列 SQL 更新视图:
CREATE VIEW [Current Product List] AS
SELECT ProductID,ProductName,Category
FROM Products
WHERE Discontinued=No
SQL 撤销视图
您可以通过 DROP VIEW命令来删除视图。
SQL DROP VIEW Syntax
DROP VIEW view_name
SQL 日期
当我们处理日期时,最难的任务恐怕是确保所插入的日期的格式,与数据库中日期列的格式相匹配。
只要数据包含的只是日期部分,运行查询就不会出问题。但是,如果涉及时间,情况就有点复杂了。
在讨论日期查询的复杂性之前,我们先来看看最重要的内建日期处理函数。
MySQL Date 函数
下面的表格列出了 MySQL中最重要的内建日期函数:
函数 | 描述 |
返回当前的日期和时间 | |
返回当前的日期 | |
返回当前的时间 | |
提取日期或日期/时间表达式的日期部分 | |
返回日期/时间按的单独部分 | |
给日期添加指定的时间间隔 | |
从日期减去指定的时间间隔 | |
返回两个日期之间的天数 | |
用不同的格式显示日期/时间 |
SQL Server Date 函数
下面的表格列出了 SQLServer 中最重要的内建日期函数:
函数 | 描述 |
返回当前日期和时间 | |
返回日期/时间的单独部分 | |
在日期中添加或减去指定的时间间隔 | |
返回两个日期之间的时间 | |
用不同的格式显示日期/时间 |
SQL Date 数据类型
MySQL使用下列数据类型在数据库中存储日期或日期/时间值:
- DATE - 格式 YYYY-MM-DD
- DATETIME - 格式: YYYY-MM-DD HH:MM:SS
- TIMESTAMP - 格式: YYYY-MM-DD HH:MM:SS
- YEAR - 格式 YYYY 或 YY
SQL Server使用下列数据类型在数据库中存储日期或日期/时间值:
- DATE - 格式 YYYY-MM-DD
- DATETIME - 格式: YYYY-MM-DD HH:MM:SS
- SMALLDATETIME - 格式: YYYY-MM-DD HH:MM:SS
- TIMESTAMP - 格式: 唯一的数字
SQL 日期处理
如果不涉及时间部分,那么我们可以轻松地比较两个日期!
假设我们有下面这个"Orders" 表:
OrderId | ProductName | OrderDate |
1 | computer | 2008-12-26 |
2 | printer | 2008-12-26 |
3 | electrograph | 2008-11-12 |
4 | telephone | 2008-10-19 |
现在,我们希望从上表中选取OrderDate 为 "2008-12-26" 的记录。
我们使用如下 SELECT语句:
SELECT * FROM Orders WHERE OrderDate='2008-12-26'
结果集:
OrderId | ProductName | OrderDate |
1 | computer | 2008-12-26 |
3 | electrograph | 2008-12-26 |
现在假设"Orders" 类似这样(请注意 "OrderDate" 列中的时间部分):
OrderId | ProductName | OrderDate |
1 | computer | 2008-12-26 16:23:55 |
2 | printer | 2008-12-26 10:45:26 |
3 | electrograph | 2008-11-12 14:12:08 |
4 | telephone | 2008-10-19 12:56:10 |
如果我们使用上面的SELECT 语句:
SELECT * FROM Orders WHERE OrderDate='2008-12-26'
那么我们得不到结果。这是由于该查询不含有时间部分的日期。
提示:如果您希望使查询简单且更易维护,那么请不要在日期中使用时间部分!
NULL 值是遗漏的未知数据。
默认地,表的列可以存放 NULL 值。
本章讲解 IS NULL 和 IS NOT NULL 操作符。
SQL NULL 值
如果表中的某个列是可选的,那么我们可以在不向该列添加值的情况下插入新记录或更新已有的记录。这意味着该字段将以NULL 值保存。
NULL值的处理方式与其他值不同。
NULL用作未知的或不适用的值的占位符。
注释:无法比较 NULL 和 0;它们是不等价的。
SQL 的 NULL 值处理
请看下面的"Persons" 表:
Id | LastName | FirstName | Address | City |
1 | Adams | John |
| London |
2 | Bush | George | Fifth Avenue | New York |
3 | Carter | Thomas |
| Beijing |
假如"Persons" 表中的 "Address" 列是可选的。这意味着如果在 "Address"列插入一条不带值的记录,"Address" 列会使用 NULL 值保存。
那么我们如何测试 NULL值呢?
无法使用比较运算符来测试NULL 值,比如 =, <, 或者 <>。
我们必须使用 IS NULL和 IS NOT NULL 操作符。
SQL IS NULL
我们如何仅仅选取在"Address" 列中带有 NULL 值的记录呢?
我们必须使用 IS NULL操作符:
SELECT LastName,FirstName,Address FROMPersons
WHERE Address IS NULL
结果集:
LastName | FirstName | Address |
Adams | John |
|
Carter | Thomas |
|
提示:请始终使用 IS NULL 来查找 NULL值。
SQL IS NOT NULL
我们如何选取在"Address" 列中不带有 NULL 值的记录呢?
我们必须使用 IS NOTNULL 操作符:
SELECT LastName,FirstName,Address FROMPersons
WHERE Address IS NOT NULL
结果集:
LastName | FirstName | Address |
Bush | George | Fifth Avenue |
在下一节中,我们了解ISNULL()、NVL()、IFNULL() 和 COALESCE() 函数。