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" 列中僅選取唯一不同的值，我們需要使用 SELECT DISTINCT 語句：
SELECT DISTINCT Company FROM Orders
結果：
|
Company
|
|
IBM
|
|
W3School
|
|
Apple
|
現在，在結果集中，"W3School" 僅被列出了一次。
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 WHERE FirstName='Thomas' AND LastName='Carter'
結果：
|
LastName
|
FirstName
|
Address
|
City
|
|
Carter
|
Thomas
|
Changan Street
|
Beijing
|
OR
運算符實例
使用 OR 來顯示所有姓為 "Carter" 或者名為 "Thomas" 的人：
SELECT * FROM Persons WHERE firstname='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' OR FirstName='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 FROM Orders ORDER BY Company
結果：
|
Company
|
OrderNumber
|
|
Apple
|
4698
|
|
IBM
|
3532
|
|
W3School
|
6953
|
|
W3School
|
2356
|
實例
2
以字母順序顯示公司名稱（Company），並以數字順序顯示順序號（OrderNumber）：
SELECT Company, OrderNumber FROM Orders ORDER BY Company, OrderNumber
結果：
|
Company
|
OrderNumber
|
|
Apple
|
4698
|
|
IBM
|
3532
|
|
W3School
|
2356
|
|
W3School
|
6953
|
實例
3
以逆字母順序顯示公司名稱：
SELECT Company, OrderNumber FROM Orders ORDER BY Company DESC
結果：
|
Company
|
OrderNumber
|
|
W3School
|
6953
|
|
W3School
|
2356
|
|
IBM
|
3532
|
|
Apple
|
4698
|
實例
4
以逆字母順序顯示公司名稱，並以數字順序顯示順序號：
SELECT Company, OrderNumber FROM Orders ORDER BY Company 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' WHERE LastName = '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
|
刪除某行
"Fred Wilson" 會被刪除：
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|percent column_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 子句中搜索列中的指定模式。
SQL LIKE
操作符語法
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
操作符在
WH, ERE
子句中使用，作用是選取介於兩個值之間的數據范圍。
BETWEEN
操作符
操作符 BETWEEN ... AND 會選取介於兩個值之間的數據范圍。這些值可以是數值、文本或者日期。
SQL BETWEEN
語法
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。
數據庫中的表可通過鍵將彼此聯系起來。主鍵（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
|
請注意，"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 RIGHT JOIN
關鍵字
RIGHT JOIN 關鍵字會右表 (table_name2) 那里返回所有的行，即使在左表 (table_name1) 中沒有匹配的行。
RIGHT JOIN
關鍵字語法
SELECT column_name(s)
FROM table_name1
RIGHT JOIN table_name2
ON table_name1.column_name=table_name2.column_name
注釋：在某些數據庫中， RIGHT JOIN 稱為 RIGHT 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
|
右連接（
RIGHT JOIN
）實例
現在，我們希望列出所有的定單，以及定購它們的人 - 如果有的話。
您可以使用下面的 SELECT 語句：
SELECT Persons.LastName, Persons.FirstName, Orders.OrderNo
FROM Persons
RIGHT 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
|
|
|
|
34764
|
RIGHT JOIN 關鍵字會從右表 (Orders) 那里返回所有的行，即使在左表 (Persons) 中沒有匹配的行
SQL FULL JOIN
關鍵字
只要其中某個表存在匹配，FULL JOIN 關鍵字就會返回行。
FULL JOIN
關鍵字語法
SELECT column_name(s)
FROM table_name1
FULL JOIN table_name2
ON table_name1.column_name=table_name2.column_name
注釋：在某些數據庫中， FULL JOIN 稱為 FULL 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
|
全連接（
FULL JOIN
）實例
現在，我們希望列出所有的人，以及他們的定單，以及所有的定單，以及定購它們的人。
您可以使用下面的 SELECT 語句：
SELECT Persons.LastName, Persons.FirstName, Orders.OrderNo
FROM Persons
FULL 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
|
|
|
|
|
34764
|
FULL JOIN 關鍵字會從左表 (Persons) 和右表 (Orders) 那里返回所有的行。如果 "Persons" 中的行在表 "Orders" 中沒有匹配，或者如果 "Orders" 中的行在表 "Persons" 中沒有匹配，這些行同樣會列出。
SQL UNION
操作符
UNION 操作符用於合並兩個或多個 SELECT 語句的結果集。
請注意，UNION 內部的 SELECT 語句必須擁有相同數量的列。列也必須擁有相似的數據類型。同時，每條 SELECT 語句中的列的順序必須相同。
SQL UNION
語法
SELECT column_name(s) FROM table_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 FROM Employees_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 FROM Employees_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 語句常用於創建表的備份復件或者用於對記錄進行存檔。
SQL SELECT 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 兩個表中取得的信息：
SELECT Persons.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" 的數據庫。
我們使用下面的 CREATE DATABASE 語句：
CREATE DATABASE my_db
可以通過 CREATE TABLE 來添加數據庫表。
CREATE TABLE
語句
CREATE TABLE 語句用於創建數據庫中的表。
SQL CREATE TABLE
語法
CREATE TABLE 表名稱
(
列名稱1 數據類型,
列名稱2 數據類型,
列名稱3 數據類型,
....
)
數據類型（data_type）規定了列可容納何種數據類型。下面的表格包含了SQL中最常用的數據類型：
|
數據類型
|
描述
|
|
· integer(size)
· int(size)
· smallint(size)
· tinyint(size)
|
僅容納整數。在括號內規定數字的最大位數。
|
|
· decimal(size,d)
· numeric(size,d)
|
容納帶有小數的數字。
"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
約束
NOT NULL 約束強制列不接受 NULL 值。
NOT NULL 約束強制字段始終包含值。這意味着，如果不向字段添加值，就無法插入新紀錄或者更新記錄。
下面的 SQL 語句強制 "Id_P" 列和 "LastName" 列不接受 NULL 值：
CREATE TABLE Persons
(
Id_P int NOT NULL,
LastName varchar(255) NOT NULL,
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)
)
SQL Server / 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_PersonID UNIQUE (Id_P,LastName)
)
SQL UNIQUE Constraint on ALTER TABLE
當表已被創建時，如需在 "P_Id" 列創建 UNIQUE 約束，請使用下列 SQL：
MySQL / SQL Server / Oracle / MS Access:
ALTER TABLE Persons
ADD UNIQUE (P_Id)
如需命名 UNIQUE 約束，並定義多個列的 UNIQUE 約束，請使用下面的 SQL 語法：
MySQL / SQL Server / Oracle / MS Access:
ALTER TABLE Persons
ADD CONSTRAINT uc_PersonID UNIQUE (P_Id,LastName)
撤銷
UNIQUE
約束
如需撤銷 UNIQUE 約束，請使用下面的 SQL：
MySQL:
ALTER TABLE Persons
DROP INDEX uc_PersonID
SQL Server / Oracle / MS Access:
ALTER TABLE Persons
DROP CONSTRAINT uc_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)
)
SQL Server / Oracle / MS Access:
CREATE TABLE Persons
(
Id_P int NOT NULL PRI, MARY KEY,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255)
)
如果需要命名 PRIMARY KEY 約束，以及為多個列定義 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_PersonID PRIMARY 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)
如果需要命名 PRIMARY KEY 約束，以及為多個列定義 PRIMARY KEY 約束，請使用下面的 SQL 語法：
MySQL / SQL Server / Oracle / MS Access:
ALTER TABLE Persons
ADD CONSTRAINT pk_PersonID PRIMARY KEY (Id_P,LastName)
注釋：如果您使用 ALTER TABLE 語句添加主鍵，必須把主鍵列聲明為不包含 NULL 值（在表首次創建時）。
撤銷
PRIMARY KEY
約束
如需撤銷 PRIMARY KEY 約束，請使用下面的 SQL：
MySQL:
ALTER TABLE Persons
DROP PRIMARY KEY
SQL Server / Oracle / MS Access:
ALTER TABLE Persons
DROP CONSTRAINT pk_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)
)
SQL Server / Oracle / MS Access:
CREATE TABLE Orders
(
O_Id int NOT NULL PRIMARY KEY,
OrderNo int NOT NULL,
Id_P int FOREIGN KEY REFERENCES Persons(Id_P)
)
如果需要命名 FOREIGN KEY 約束，以及為多個列定義 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),
CONSTRAINT fk_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)
如果需要命名 FOREIGN KEY 約束，以及為多個列定義 FOREIGN KEY 約束，請使用下面的 SQL 語法：
MySQL / SQL Server / Oracle / MS Access:
ALTER TABLE Orders
ADD CONSTRAINT fk_PerOrders
FOREIGN KEY (Id_P)
REFERENCES Persons(Id_P)
撤銷
FOREIGN KEY
約束
如需撤銷 FOREIGN KEY 約束，請使用下面的 SQL：
MySQL:
ALTER TABLE Orders
DROP FOREIGN KEY fk_PerOrders
SQL Server / Oracle / MS Access:
ALTER TABLE Orders
DROP CONSTRAINT fk_PerOrders
SQL CHECK
約束
CHECK 約束用於限制列中的值的范圍。
如果對單個列定義 CHECK 約束，那么該列只允許特定的值。
如果對一個表定義 CHECK 約束，那么此約束會在特定的列中對值進行限制。
SQL CHECK Constraint on CREATE TABLE
下面的 SQL 在 "Persons" 表創建時為 "Id_P" 列創建 CHECK 約束。CHECK 約束規定 "Id_P" 列必須只包含大於 0 的整數。
My SQL:
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)
)
SQL Server / 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_Person CHECK (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 CONSTRAINT chk_Person CHECK (Id_P>0 AND City='Sandnes')
撤銷
CHECK
約束
如需撤銷 CHECK 約束，請使用下面的 SQL：
SQL Server / Oracle / MS Access:
ALTER TABLE Persons
DROP CONSTRAINT chk_Person
SQL DEFAULT
約束
DEFAULT 約束用於向列中插入默認值。
如果沒有規定其他的值，那么會將默認值添加到所有的新紀錄。
SQL DEFAULT Constraint on CREATE TABLE
下面的 SQL 在 "Persons" 表創建時為 "City" 列創建 DEFAULT 約束：
My SQL / 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'
SQL Server / Oracle / MS Access:
ALTER TABLE Persons
ALTER COLUMN City SET DEFAULT 'SANDNES'
撤銷
DEFAULT
約束
如需撤銷 DEFAULT 約束，請使用下面的 SQL：
MySQL:
ALTER TABLE Persons
ALTER City DROP DEFAULT
SQL Server / Oracle / MS Access:
ALTER TABLE Persons
ALTER COLUMN City DROP DEFAULT
CREATE INDEX
語句用於在表中創建索引。
在不讀取整個表的情況下，索引使數據庫應用程序可以更快地查找數據。
索引
您可以在表中創建索引，以便更加快速高效地查詢數據。
用戶無法看到索引，它們只能被用來加速搜索/查詢。
注釋：更新一個包含索引的表需要比更新一個沒有索引的表更多的時間，這是由於索引本身也需要更新。因此，理想的做法是僅僅在常常被搜索的列（以及表）上面創建索引。
SQL CREATE INDEX
語法
在表上創建一個簡單的索引。允許使用重復的值：
CREATE INDEX index_name
ON table_name (column_name)
注釋："column_name" 規定需要索引的列。
SQL CREATE 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
語句
我們可以使用 DROP INDEX 命令刪除表格中的索引。
用於
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
語句
如果我們僅僅需要除去表內的數據，但並不刪除表本身，那么我們該如何做呢？
請使用 TRUNCATE TABLE 命令（僅僅刪除表格中的數據）：
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 NULL AUTO_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 KEY IDENTITY,
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 KEY AUTOINCREMENT,
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 字段（該對象生成數字序列）。
請使用下面的 CREATE SEQUENCE 語法：
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"。