在20世紀50年代中期以前的計算機誕生初期，其處理能力很有限，只能夠完成一些簡單的運算，資料處理能力也很有限，這使得當時的計算機只能夠用於科學和工程計算。計算機上沒有專用的管理資料的軟體，資料由計算機或處理它的程式自行攜帶。當資料的儲存格式、讀寫路徑或方法發生變化的時候，其處理程式也必須要做出相應的改變以保持程式的正確性。

1.1.2、檔案系統

20世紀50年代後期到60年代中期，隨著硬體和軟體技術的發展，計算機不僅用於科學計算，還大量用於商業管理中。在這一時期，資料和程式在儲存位置上已經完全分開，資料被單獨組織成檔案儲存到外部儲存裝置上，這樣資料檔案就可以為多個不同的程式在不同的時間所使用。
雖然程式和資料在儲存位置上分開了，而且作業系統也可以幫助我們對完成了資料的儲存位置和存取路徑的管理，但是程式設計仍然受到資料儲存格式和方法的影響，不能夠完全獨立於資料，而且資料的冗餘較大。

1.1.3、資料庫管理系統

從20世紀70年代以來，計算機軟硬體技術取得了飛躍式的發展，這一時期最主要的發展就是產生了真正意義上的資料庫管理系統，它使得應用程式和資料之間真正的實現的介面統一、資料共享等，這樣應用程式都可以按照統一的方式直接操作資料，也就是應用程式和資料都具有了高度的獨立性。

1.2、常見資料庫技術品牌、服務與架構

發展了這麼多年市場上出現了許多的資料庫系統，最強的個人認為是Oracle，當然還有許多如：DB2、Microsoft SQL Server、MySQL、SyBase等，下圖列出常見資料庫技術品牌、服務與架構。

1.3、資料庫分類

資料庫通常分為層次式資料庫、網路式資料庫和關係式資料庫三種。

而不同的資料庫是按不同的資料結構來聯絡和組織的。

而在當今的網際網路中，最常見的資料庫模型主要是兩種，即關係型資料庫和非關係型資料庫。

1.3.1、關係型資料庫

當前在成熟應用且服務與各種系統的主力資料庫還是關係型資料庫。

代表：Oracle、SQL Server、MySQL

1.3.2、非關係型資料庫

隨著時代的進步與發展的需要，非關係型資料庫應運而生。

代表：Redis、Mongodb

NoSQL資料庫在儲存速度與靈活性方面有優勢，也常用於快取。

1.4、資料庫規範化

經過一系列的步驟，我們現在終於將客戶的需求轉換為資料表並確立這些表之間的關係，那麼是否我們現在就可以在開發中使用呢？答案否定的，為什麼呢！同一個專案，很多人蔘與了需求的分析，資料庫的設計，不同的人具有不同的想法，不同的部門具有不同的業務需求，我們以此設計的資料庫將不可避免的包含大量相同的資料，在結構上也有可能產生衝突，在開發中造成不便。

1.4.1. 什麼是正規化

要設計規範化的資料庫，就要求我們根據資料庫設計正規化――也就是資料庫設計的規範原則來做。正規化可以指導我們更好地設計資料庫的表結構，減少冗餘的資料，藉此可以提高資料庫的儲存效率，資料完整性和可擴充套件性。

設計關係資料庫時，遵從不同的規範要求，設計出合理的關係型資料庫，這些不同的規範要求被稱為不同的正規化，各種正規化呈遞次規範，越高的正規化資料庫冗餘越小。目前關係資料庫有六種正規化：第一正規化（1NF）、第二正規化（2NF）、第三正規化（3NF）、巴德斯科範式（BCNF）、第四正規化(4NF）和第五正規化（5NF，又稱完美正規化）。滿足最低要求的正規化是第一正規化（1NF）。在第一正規化的基礎上進一步滿足更多規範要求的稱為第二正規化（2NF），其餘正規化以次類推。一般說來，資料庫只需滿足第三正規化(3NF）就行了。

1.4.2. 三大正規化

第一正規化（1NF）

所謂第一正規化（1NF）是指在關係模型中，對列新增的一個規範要求，所有的列都應該是原子性的，即資料庫表的每一列都是不可分割的原子資料項，而不能是集合，陣列，記錄等非原子資料項。即實體中的某個屬性有多個值時，必須拆分為不同的屬性。在符合第一正規化（1NF）表中的每個域值只能是實體的一個屬性或一個屬性的一部分。簡而言之，第一正規化就是無重複的域。

例如:表1-1中，其中”工程地址”列還可以細分為省份，城市等。在國外，更多的程式把”姓名”列也分成2列,即”姓”和“名”。

雖然第一正規化要求各列要儲存原子性，不能再分，但是這種要求和我們的需求是相關聯的，如上表中我們對”工程地址”沒有省份，城市這樣方面的查詢和應用需求，則不需拆分，”姓名”列也是同樣如此。

表1-1 原始表

工程號	工程名稱	工程地址	員工編號	員工名稱	薪資待遇	職務
P001	港珠澳大橋	廣東珠海	E0001	Jack	6000/月	工人
P001	港珠澳大橋	廣東珠海	E0002	Join	7800/月	工人
P001	港珠澳大橋	廣東珠海	E0003	Apple	8000/月	高階技工
P002	南海航天	海南三亞	E0001	Jack	5000/月	工人

第二正規化（2NF）

在1NF的基礎上，非Key屬性必須完全依賴於主鍵。第二正規化（2NF）是在第一正規化（1NF）的基礎上建立起來的，即滿足第二正規化（2NF）必須先滿足第一正規化（1NF）。第二正規化（2NF）要求資料庫表中的每個例項或記錄必須可以被唯一地區分。選取一個能區分每個實體的屬性或屬性組，作為實體的唯一標識。

第二正規化（2NF）要求實體的屬性完全依賴於主關鍵字。所謂完全依賴是指不能存在僅依賴主關鍵字一部分的屬性，如果存在，那麼這個屬性和主關鍵字的這一部分應該分離出來形成一個新的實體，新實體與原實體之間是一對多的關係。為實現區分通常需要為表加上一個列，以儲存各個例項的唯一標識。簡而言之，第二正規化就是在第一正規化的基礎上屬性完全依賴於主鍵。

例如:表1-1中，一個表描述了工程資訊，員工資訊等。這樣就造成了大量資料的重複。按照第二正規化，我們可以將表1-1拆分成表1-2和表1-3：

l 工程資訊表：（工程編號，工程名稱，工程地址）：

表1-2 工程資訊表

工程編號	工程名稱	工程地址
P001	港珠澳大橋	廣東珠海
P002	南海航天	海南三亞

l 員工資訊表（員工編號，員工名稱，職務，薪資水平）：

表1-3 員工資訊表

員工編號	員工姓名	職務	薪資水平
E0001	Jack	工人	3000/月
E0002	Join	工人	3000/月
E0003	Apple	高階技工	6000/月

這樣，表1-1就變成了兩張表，每個表只描述一件事，清晰明瞭。

第三正規化（3NF）

第三正規化是在第二正規化基礎上，更進一層，第三正規化的目標就是確保表中各列與主鍵列直接相關，而不是間接相關。即各列與主鍵列都是一種直接依賴關係，則滿足第三正規化。

第三正規化要求各列與主鍵列直接相關，我們可以這樣理解，假設張三是李四的兵，王五則是張三的兵，這時王五是不是李四的兵呢?從這個關係中我們可以看出，王五也是李四的兵，因為王五依賴於張三，而張三是李四的兵，所以王五也是。這中間就存在一種間接依賴的關係而非我們第三正規化中強調的直接依賴。

現在我們來看看在第二正規化的講解中，我們將表1-1拆分成了兩張表。這兩個表是否符合第三正規化呢。在員工資訊表中包含：”員工編號”、”員工名稱”、”職務”、”薪資水平”，而我們知道，薪資水平是有職務決定，這裡”薪資水平”通過”職務”與員工相關，則不符合第三正規化。我們需要將員工資訊表進一步拆分，如下:

l 員工資訊表：員工編號，員工名稱，職務

l 職務表：職務編號，職務名稱，薪資水平

現在我們已經瞭解了資料庫規範化設計的三大正規化，下面我們再來看看對錶1-1優化後的資料表：

員工資訊表(Employee)

員工編號	員工姓名	職務編號
E0001	Jack	1
E0002	Join	1
E0003	Apple	2

工程資訊表(ProjectInfo)

工程編號	工程名稱	工程地址
P001	港珠澳大橋	廣東珠海
P002	南海航天	海南三亞

職務表(Duty)

職務編號	職務名稱	工資待遇
1	工人	3000/月
2	高階技工	6000/月

工程參與人員記錄表（Project_ Employee_info）

編號	工程編號	人員編號
1	P001	E0001
2	P001	E0002
3	P002	E0003

通過對比我們發現，表多了，關係複雜了，查詢資料變的麻煩了，程式設計中的難度也提高了，但是各個表中內容更清晰了，重複的資料少了，更新和維護變的更容易了，哪麼如何平衡這種矛盾呢？

1.4.3. 正規化與效率

在我們設計資料庫時，設計人員、客戶、開發人員通常對資料庫的設計有一定的矛盾，客戶更喜歡方便，清晰的結果，開發人員也希望資料庫關係比較簡單，降低開發難度，而設計人員則需要應用三大正規化對資料庫進行嚴格規範化，減少資料冗餘，提高資料庫可維護性和擴充套件性。由此可以看出，為了滿足三大正規化，我們資料庫設計將會與客戶、開發人員產生分歧，所以在實際的資料庫設計中，我們不能一味的追求規範化，既要考慮三大正規化，減少資料冗餘和各種資料庫操作異常，又要充分考慮到資料庫的效能問題，允許適當的資料庫冗餘。

二、MySQL介紹

2.1、MySQL概要

MySQL是一個關係型資料庫管理系統，由瑞典MySQL AB 公司開發，目前屬於 Oracle 旗下產品。MySQL 是最流行的關係型資料庫管理系統之一，在 WEB 應用方面，MySQL是最好的 RDBMS (Relational Database Management System，關係資料庫管理系統) 應用軟體之一。

MySQL是一種關係資料庫管理系統，關係資料庫將資料儲存在不同的表中，而不是將所有資料放在一個大倉庫內，這樣就增加了速度並提高了靈活性。
MySQL所使用的 SQL 語言是用於訪問資料庫的最常用標準化語言。MySQL 軟體採用了雙授權政策，分為社群版和商業版，由於其體積小、速度快、總體擁有成本低，尤其是開放原始碼這一特點，一般中小型網站的開發都選擇 MySQL 作為網站資料庫。

MySQL官網：https://www.mysql.com/

MySQL下載：https://www.mysql.com/downloads/

2.2、系統特性

1．使用 C和 C++編寫，並使用了多種編譯器進行測試，保證了原始碼的可移植性。

2．支援 AIX、FreeBSD、HP-UX、Linux、Mac OS、NovellNetware、OpenBSD、OS/2 Wrap、Solaris、Windows等多種作業系統。

3．為多種程式語言提供了 API。這些程式語言包括 C、C++、Python、Java、Perl、PHP、Eiffel、Ruby,.NET和 Tcl 等。

4．支援多執行緒，充分利用 CPU 資源。

5．優化的 SQL查詢演算法，有效地提高查詢速度。

6．既能夠作為一個單獨的應用程式應用在客戶端伺服器網路環境中，也能夠作為一個庫而嵌入到其他的軟體中。

7．提供多語言支援，常見的編碼如中文的 GB 2312、BIG5，日文的 Shift_JIS等都可以用作資料表名和資料列名。

8．提供 TCP/IP、ODBC 和 JDBC等多種資料庫連線途徑。

9．提供用於管理、檢查、優化資料庫操作的管理工具。

10．支援大型的資料庫。可以處理擁有上千萬條記錄的大型資料庫。

11．支援多種儲存引擎。

12.MySQL 是開源的，所以你不需要支付額外的費用。

13.MySQL 使用標準的 SQL資料語言形式。

14.MySQL 對 PHP 有很好的支援，PHP是目前最流行的 Web 開發語言。

15.MySQL是可以定製的，採用了 GPL協議，你可以修改原始碼來開發自己的 MySQL 系統。

16.線上 DDL/更改功能，資料架構支援動態應用程式和開發人員靈活性（5.6新增）

17.複製全域性事務標識，可支援自我修復式叢集（5.6新增）

18.複製無崩潰從機，可提高可用性（5.6新增）

19.複製多執行緒從機，可提高效能（5.6新增）

20.3倍更快的效能（5.7新增）

21.新的優化器（5.7新增）

22.原生JSON支援（5.7新增）

23.多源複製（5.7新增）

24.GIS的空間擴充套件（5.7新增）

2.3、儲存引擎

MySQL資料庫根據應用的需要準備了不同的引擎，不同的引擎側重點不一樣，區別如下：

MyISAM MySQL 5.0 之前的預設資料庫引擎，最為常用。擁有較高的插入，查詢速度，但不支援事務

InnoDB 事務型資料庫的首選引擎，支援ACID事務，支援行級鎖定, MySQL 5.5 起成為預設資料庫引擎

BDB源自 Berkeley DB，事務型資料庫的另一種選擇，支援Commit 和Rollback 等其他事務特性

Memory 所有資料置於記憶體的儲存引擎，擁有極高的插入，更新和查詢效率。但是會佔用和資料量成正比的記憶體空間。並且其內容會在 MySQL 重新啟動時丟失

Merge 將一定數量的 MyISAM 表聯合而成一個整體，在超大規模資料儲存時很有用\

Archive 非常適合儲存大量的獨立的，作為歷史記錄的資料。因為它們不經常被讀取。Archive 擁有高效的插入速度，但其對查詢的支援相對較差

Federated 將不同的 MySQL 伺服器聯合起來，邏輯上組成一個完整的資料庫。非常適合分散式應用

Cluster/NDB 高冗餘的儲存引擎，用多臺資料機器聯合提供服務以提高整體效能和安全性。適合資料量大，安全和效能要求高的應用

CSV 邏輯上由逗號分割資料的儲存引擎。它會在資料庫子目錄裡為每個資料表建立一個 .csv 檔案。這是一種普通文字檔案，每個資料行佔用一個文字行。CSV 儲存引擎不支援索引。

BlackHole 黑洞引擎，寫入的任何資料都會消失，一般用於記錄 binlog 做複製的中繼

EXAMPLE 儲存引擎是一個不做任何事情的存根引擎。它的目的是作為 MySQL 原始碼中的一個例子，用來演示如何開始編寫一個新儲存引擎。同樣，它的主要興趣是對開發者。EXAMPLE 儲存引擎不支援編索引。

另外，MySQL 的儲存引擎介面定義良好。有興趣的開發者可以通過閱讀文件編寫自己的儲存引擎。

三、快速安裝執行MySQL資料庫

MySQL以前一直是開源免費的，被Oracle收購後有些變化：以前的版本都是免費的，社群版按GPL協議開源免費，商業版提供更加豐富的功能，但收費。

社群版的下載地址：https://dev.mysql.com/downloads/（免費）

企業版的下載地址：https://www.mysql.com/downloads/（收費）

3.1、使用綠色版

為了方便快捷的使用MySQL我已經準備好了一個綠化了的MySQL，解壓後就可以直接使用，不需要任何配置。

下載地址1：https://pan.baidu.com/s/1K08GU-E4CyEKKIseBYwRYA 密碼: e59m

下載地址2：http://download.csdn.net/detail/zhangguo5/9773842

下載後直接解壓：

點選啟動PStart.exe這是一個自定義選單的小工具，為了整理資源用的。

裡面有兩個MySQL的綠色版軟體5.0,5.5

Navicat for MySQL是一個數據庫客戶端管理工具

點選啟動PStart.exe後的結果如下：

點選啟動MySQL服務，執行Navicat for MySQL即可。

*注意：上面的PStart只是一個整理文件資料的工具，並非必要，如果啟動時有錯誤或為空時，可以直接關閉，直接啟動MySQL服務，如：

mysql_start.bat用於啟動MySql資料庫，mysql_stop.bat用於關閉MySql資料庫。

開發工具的啟動方式也一樣，如下所示：

navicat.exe用於啟動Navicat資料庫客戶端，最好傳送快捷方式到桌面，省去每次開啟資料夾的麻煩。

3.1.1、設定mysql遠端訪問

執行mysql 命令進入mysql 命令模式，執行如下SQL程式碼

mysql> use mysql; 
mysql> GRANT ALL ON *.* TO admin@'%' IDENTIFIED BY 'admin' WITH GRANT OPTION;

#這句話的意思，允許任何IP地址（上面的 % 就是這個意思）的電腦用admin帳戶和密碼（admin）來訪問這個MySQL Server
#必須加類似這樣的帳戶，才可以遠端登陸。 root帳戶是無法遠端登陸的，只可以本地登陸

3.1.2、修改mysql使用者密碼

1.mysqladmin命令

格式如下（其中，USER為使用者名稱，PASSWORD為新密碼）：

mysqladmin -u USER -p password PASSWORD

該命令之後會提示輸入原密碼，輸入正確後即可修改。
例如，設定root使用者的密碼為123456，則

mysqladmin -u root -p password 123456

2.UPDATE user 語句

這種方式必須是先用root帳戶登入mysql，然後執行：

UPDATE user SET password=PASSWORD('123456') WHERE user='root';
FLUSH PRIVILEGES;

3.SET PASSWORD 語句

這種方式也需要先用root命令登入mysql，然後執行：

SET PASSWORD FOR root=PASSWORD('123456');

4.root密碼丟失的情況

使用 MySQL 自帶的一個工具"MySQL GUI Tools"，我一直用的是5.0版本的。在安裝目錄中執行一個程式 MySQLSystemTrayMonitor.exe，執行完後在系統托盤會出現圖示。如果MySQL服務尚未安裝，則不會出現，可先通過Action>Manage MySQL Instances 先配置和安裝服務。如果已經安裝服務，滑鼠右鍵點選後，會出現"Configure Instance"的選單。點選後出現如下MySQL Administrator視窗：
假如原來的服務配置都正常的情況下，選中左側列表中的“啟動變數”，並在相應的右側標籤中選擇“安全”，勾選“禁用grant表”，然後“應用更改”。
並回到左側的“伺服器控制”，和右側相應的“開始/停止服務”標籤，點選啟動服務。此時，連線mysql已經不需要使用者名稱和密碼了，你可以修改root密碼。

3.1.2、安裝服務

首先我們先進入mysql的安裝目錄下的bin目錄、之後開啟DOS命令視窗，進入該目錄下（一定要進入該目錄，否則操作錯誤）

執行DOS命令：

輸入命令：mysqld --install,之後出現如下介面。提示安裝服務成功。

注意是mysqld --install不是mysql --install

如果要解除安裝服務，可以輸入如下命令：mysqld --remove。出現如下介面。提示移除服務成功。

3.2、使用安裝版

MySQL5.5.27_64位安裝包下載地址1: https://pan.baidu.com/s/1minwz1m 密碼: ispn

MySQL5.5.27_64位安裝包下載地址2:http://download.csdn.net/detail/zhangguo5/9775460

MySQL5.7.17安裝包官網下載地址:https://dev.mysql.com/downloads/windows/installer/

選擇自定義：

安裝的元件資訊：

伺服器軟體目錄：

資料目錄：

點選install安裝即可：

配置：

機器型別

是否支援事務功能：

innodb表空間：

連線數量：

字符集設定：

配置windows管理相關：

配置安全選項，設定管理員的使用者名稱與密碼：

最後執行配置即可：

配置後，會啟動服務。

新版的MySQL安裝包大了很多，安裝過程也有些不一樣。

四、使用GUI操作MySQL

4.1、關係型資料庫的典型概念

資料庫 databse：資料的倉庫

表 table：資料是儲存在表內，儲存在一個表內的資料，應該具有相同的資料格式

行：行用於記錄資料

記錄：行內的資料

列：列用於規定資料格式

欄位：資料的某個列

SQL：用來管理資料的語言。結構化查詢語言（SQL，Structured Query Language）

主鍵：唯一地標識表中的某一條記錄，不能空，不能重複

4.2、登入資料庫

*連線本地資料庫時需要啟動服務

4.3、建立資料庫

4.4、建立表

列的型別：

數字型別

整數: tinyint、smallint、mediumint、int、bigint
浮點數: float、double、real、decimal
日期和時間: date、time、datetime、timestamp、year

字串型別
字串: char、varchar
文字: tinytext、text、mediumtext、longtext

二進位制(可用來儲存圖片、音樂等): tinyblob、blob、mediumblob、longblob

列的約束：

4.5、管理資料

4.5.1、新增資料

雙擊新建好的表名，開啟表，就可以新增資料了。

4.5.2、刪除資料

4.5.3、修改表結構

如果想向現有的表中新增一列，則可以修改表結構：

4.5.4、外來鍵

上面這個學生表是有些問題的：

a)、不便於修改，比如教室換成了305教室，則每個學員都要修改

b)、資料冗餘，大量的重複資料

將表拆分成兩個，分解後問題解決，如下圖所示：

這裡的班級編號就是外來鍵，可以空，但不為空時他的值一定在要引用表中存在。如果學生表中的編號是主鍵這裡就不應該重複，外來鍵則可以重複也允許為空。

新增外來鍵：

班級表:

學生表：

新增外來鍵：

刪除與更新時可以實現級聯更新與刪除，當更新設定為CASCADE時主鍵變化引用主鍵的表也會一起變化，當刪除設定為CASCADE時刪除主鍵表，引用的記錄都將被刪除。

create table s_orderform(
      o_id </span><span style="color: rgba(0, 0, 255, 1)">int</span> auto_increment <span style="color: rgba(0, 0, 255, 1)">primary</span> <span style="color: rgba(0, 0, 255, 1)">key</span><span style="color: rgba(0, 0, 0, 1)">,
     o_buyer_id </span><span style="color: rgba(0, 0, 255, 1)">int</span><span style="color: rgba(0, 0, 0, 1)">,
     o_seller_id </span><span style="color: rgba(0, 0, 255, 1)">int</span><span style="color: rgba(0, 0, 0, 1)">,
     o_totalprices </span><span style="color: rgba(0, 0, 255, 1)">double</span><span style="color: rgba(0, 0, 0, 1)">,
     o_state </span><span style="color: rgba(0, 0, 255, 1)">varchar</span>(<span style="color: rgba(128, 0, 0, 1); font-weight: bold">50</span><span style="color: rgba(0, 0, 0, 1)">),
     o_information </span><span style="color: rgba(0, 0, 255, 1)">varchar</span>(<span style="color: rgba(128, 0, 0, 1); font-weight: bold">200</span><span style="color: rgba(0, 0, 0, 1)">),
     </span><span style="color: rgba(0, 0, 255, 1)">foreign</span> <span style="color: rgba(0, 0, 255, 1)">key</span>(o_buyer_id) <span style="color: rgba(0, 0, 255, 1)">references</span><span style="color: rgba(0, 0, 0, 1)"> s_user(u_id),      #外鏈到s_user表的u_id欄位
     </span><span style="color: rgba(0, 0, 255, 1)">foreign</span> <span style="color: rgba(0, 0, 255, 1)">key</span>(o_seller_id) <span style="color: rgba(0, 0, 255, 1)">references</span><span style="color: rgba(0, 0, 0, 1)"> s_user(u_id)      #外鏈到s_user表的u_id欄位

)

4.5.5、唯一鍵

唯一鍵，也稱(唯一約束)，和主鍵的區別是可以為有多個唯一鍵並且值可以為NULL，但NULL也不能重複，也就是說只能有一行的值為NULL。它會隱式的建立唯一索引。

設定方法：索引 --> 新增索引 --> 欄位名新增你想設定唯一約束的列 --> 索引型別選擇 Unique

#查詢
select id,name from yuangong
select * from yuangong
select * from yuangong where salary>5000
增加
INSERT into yuangong(name,salary,bumenId,mobile) value('張為劍',2190.6,2,19889007867);
INSERT into yuangong(name,salary,bumenId,mobile) value('張娜拉',9871.6,1,19889007777);
修改
update yuangong set salary=salary+1 where id=7
刪除
INSERT into yuangong(name,salary,bumenId,mobile) value('張拉拉',9871.6,1,19889007777);
delete from yuangong where id=8

4.6、上機練習

1、請建立一個新的資料庫叫HR，在HR資料庫中新增EMP表，EMP表的表結構如下所示

EMP表：員工資訊

№	名稱	型別	描述
1	EMPNO	int	僱員的編號，主鍵，自動增長
2	ENAME	VARCHAR(10)	僱員的姓名，由10位字元所組成，不為空，唯一鍵
3	JOB	VARCHAR(9)	僱員的職位
4	MGR	int	僱員對應的領導編號，領導也是僱員，可空（可刪除這一列）
5	HIREDATE	TimeStamp	僱員的僱傭日期,預設為當前日期
6	SAL	Numeric(7,2)	基本工資，其中有兩位小數，五位整數，一共是七位
7	COMM	Numeric(7,2)	獎金，佣金
8	DEPTNO	int	僱員所在的部門編號，可空，外來鍵fk_deptno
9	DETAIL	Text	備註，可空

Dept：部門表

№	名稱	型別	描述
1	DeptNO	int	部門的編號，主鍵，自動增長
2	DNAME	VARCHAR(10)	部門名，由50位字元所組成，不為空，唯一鍵
3	DTel	VARCHAR(10)	電話，可空

2、根據上面的表結構完成表的建立，表名為emp

3、在表中新增5條以上的資料

4、完成下列查詢要求

4.1查詢所有員工資訊

4.2查詢所有工資介於2000-5000間的員工姓名、職位與工資

4.3查詢所有姓“張”的員工

4.4 按工資降序查詢出2014年到2015年間入職的員工

4.5、將工資普遍上調20%

4.6、將工資低於3000元的員工獎金修改為工資的2.8倍

4.7、刪除編號為5或者姓“王”的員工

五、使用SQL訪問MySQL資料庫

5.0、定義學生表Stu、商品型別與商品表

（id編號,name姓名,sex性別,age年齡,...)

指令碼：

#建立商品型別表
CREATE TABLE `category` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT COMMENT '編號',
  `name` varchar(128) NOT NULL COMMENT '型別名稱',
  `parentId` int(11) unsigned DEFAULT NULL COMMENT '父節點編號',
  PRIMARY KEY (`id`),
  UNIQUE KEY `un_category_name` (`name`),
  KEY `fk_category_parentId` (`parentId`),
  CONSTRAINT `fk_category_parentId` FOREIGN KEY (`parentId`) REFERENCES `category` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8 COMMENT='商品分類';
建立商品表
drop table if exists goods;  #刪除表
create table if not exists goods

(

id int not null primary key auto_increment comment '編號',

title varchar(128) not null unique key comment '商品名稱',

category_id int unsigned COMMENT '商品型別編號',

add_date TIMESTAMP default now() comment '上貨時間',

picture varchar(64) comment '圖片',

state int default 1 comment '狀態',

FOREIGN key (category_id) REFERENCES category(id)

)COMMENT='商品'
修改表，增加列
ALTER table goods add details text COMMENT '詳細介紹';

ALTER table goods add price DECIMAL(11,2) COMMENT '價格';
新增記錄，單行
insert into goods(title,category_id,picture,price,details,state)

VALUES('魅族魅藍note1 ',4,'pic(1).jpg',999,'好手機',default);
新增記錄，多行
insert into goods(title,category_id,picture,price,details)

select '魅族魅藍note2',4,'pic(2).jpg',889,'好手機' UNION

select 'iphone X',4,'pic(3).jpg',5889,'好手機' UNION

select '龍蝦',1,'pic(4).jpg',9.85,'好吃'
查詢
select * from goods
備份
SELECT

goods.id,

goods.title,

goods.category_id,

goods.add_date,

goods.picture,

goods.state,

goods.details,

goods.price

FROM

goods
select SYSDATE();

SELECT now();

5.0.1、新建資料庫

5.0.2、新建表

5.0.3、新建查詢

5.1、增加資料

insert 語句可以用來將一行或多行資料插到資料庫表中, 使用的一般形式如下:

Insert into 表名(欄位列表) values (值列表);

insert [into] 表名 [(列名1, 列名2, 列名3, ...)] values (值1, 值2, 值3, ...);

insert into students values(NULL, "張三", "男", 20, "18889009876");

有時我們只需要插入部分資料, 或者不按照列的順序進行插入, 可以使用這樣的形式進行插入:

insert into students (name, sex, age) values("李四", "女", 21);

#1、新增資料
insert into stu(name,sex,age) values('張學友','男',18);

insert into stu(name,sex,age) values('張娜拉','女',73);

insert into stu(name,sex,age) values('張家輝','男',23);

insert into stu(name,sex,age) values('張匯美','女',85);

insert into stu(name,sex,age) values('張鐵林','男',35);

5.2、查詢資料

select 語句常用來根據一定的查詢規則到資料庫中獲取資料, 其基本的用法為:

select 欄位名 from 表名稱 [查詢條件];

查詢學生表中的所有資訊：select * from students;

查詢學生表中所有的name與age資訊：select name, age from students;

也可以使用萬用字元 * 查詢表中所有的內容, 語句: select * from students;

#1、新增資料
insert into stu(name,sex,age) values('張學友','男',18);

insert into stu(name,sex,age) values('張娜拉','女',73);

insert into stu(name,sex,age) values('張家輝','男',23);

insert into stu(name,sex,age) values('張匯美','女',85);

insert into stu(name,sex,age) values('張鐵林','男',35);
insert into stu(name,sex,age) values('張國立','男',99);
2、查詢資料
2.1、查詢所有學生
select id,name,sex,age from stu;
2.2、查詢年齡大於80歲女學生
select id,name,sex,age from stu where age>80 and sex='女';

結果：

5.2.1、表示式與條件查詢

where 關鍵詞用於指定查詢條件, 用法形式為: select 列名稱 from 表名稱 where 條件;

以查詢所有性別為女的資訊為例, 輸入查詢語句: select * from students where sex="女";

where 子句不僅僅支援 "where 列名 = 值" 這種名等於值的查詢形式, 對一般的比較運算的運算子都是支援的, 例如 =、>、<、>=、<、!= 以及一些擴充套件運算子 is [not] null、in、like 等等。還可以對查詢條件使用 or 和 and 進行組合查詢, 以後還會學到更加高階的條件查詢方式, 這裡不再多做介紹。

示例:

查詢年齡在21歲以上的所有人資訊: select * from students where age > 21;

查詢名字中帶有 "王" 字的所有人資訊: select * from students where name like "%王%";

查詢id小於5且年齡大於20的所有人資訊: select * from students where id<5 and age>20;

5.2.2、聚合函式

獲得學生總人數：select count(*) from students

獲得學生平均分：select avg(mark) from students

獲得最高成績：select max(mark) from students

獲得最低成績：select min(mark) from students

獲得學生總成績：select sum(mark) from students

5.3、刪除資料

delete from 表名 [刪除條件];

刪除表中所有資料：delete from students;

刪除id為10的行: delete from students where id=10;

刪除所有年齡小於88歲的資料: delete from students where age<88;

#1、新增資料-----
insert into stu(name,sex,age) values('張學友','男',18);

insert into stu(name,sex,age) values('張娜拉','女',73);

insert into stu(name,sex,age) values('張家輝','男',23);

insert into stu(name,sex,age) values('張匯美','女',85);

insert into stu(name,sex,age) values('張鐵林','男',35);

insert into stu(name,sex,age) values('張國立','男',99);
2、查詢資料-----

#2.1、查詢所有學生
select id,name,sex,age from stu;
2.2、查詢年齡大於80歲女學生
select id,name,sex,age from stu where age>80 and sex='女';
2.3、查詢平均年齡
select AVG(age) from stu where sex='女';
3、修改資料-----
3.1、將編號為1的學生年齡加大1歲
update stu set age=age+1 where id=1;
3.2、將80歲以上的女學生年齡修改為90歲且將姓名後增加“老人”
CONCAT(str1,str2,...) 連線字串
update stu set age=90,name=CONCAT(name,'(老人)') where age>=80 and sex='女';
3.3、將編號4的學生名字修改為張匯美
update stu set name='張匯美' where id=4;
4、刪除資料-----
4.1、刪除年齡大於70歲的學生
delete from stu where age>70;
4.2、刪除所有學生
delete from stu;

5.4、更新資料

update 語句可用來修改表中的資料, 基本的使用形式為:

update 表名稱 set 列名稱=新值 where 更新條件;

Update 表名set 欄位=值列表更新條件

使用示例:

將id為5的手機號改為預設的"-": update students set tel=default where id=5;

將所有人的年齡增加1: update students set age=age+1;

將手機號為 13723887766 的姓名改為 "張果", 年齡改為 19: update students set name="張果", age=19 where tel="13723887766";

5.5、修改表

alter table 語句用於建立後對錶的修改, 基礎用法如下:

5.5.1、新增列

基本形式: alter table 表名 add 列名列資料型別 [after 插入位置];

示例:

在表的最後追加列 address: alter table students add address char(60);

在名為 age 的列後插入列 birthday: alter table students add birthday date after age;

5.5.2、修改列

基本形式: alter table 表名 change 列名稱列新名稱新資料型別;

示例:

將表 tel 列改名為 phone: alter table students change tel phone char(12) default "-";

將 name 列的資料型別改為 char(9): alter table students change name name char(9) not null;

5.5.3、刪除列

基本形式: alter table 表名 drop 列名稱;

示例:

刪除 age 列: alter table students drop age;

5.5.4、重命名錶

基本形式: alter table 表名 rename 新表名;

示例:

重新命名 students 表為temp: alter table students rename temp;

5.5.5、刪除表

基本形式: drop table 表名;

示例: 刪除students表: drop table students;

5.5.6、刪除資料庫

基本形式: drop database 資料庫名;

示例: 刪除lcoa資料庫: drop database lcoa;

5.5.7、一千行MySQL筆記

/* 啟動MySQL */
net start mysql
/ 連線與斷開伺服器 /

mysql -h 地址 -P 埠 -u 使用者名稱 -p 密碼
/ 跳過許可權驗證登入MySQL /

mysqld --skip-grant-tables

-- 修改root密碼

密碼加密函式password()

update mysql.user set password=password('root');
SHOW PROCESSLIST -- 顯示哪些執行緒正在執行

SHOW VARIABLES --
/ 資料庫操作 / ------------------

-- 檢視當前資料庫

select database();

-- 顯示當前時間、使用者名稱、資料庫版本

select now(), user(), version();

-- 建立庫

create database[ if not exists] 資料庫名 資料庫選項

資料庫選項：

CHARACTER SET charset_name

COLLATE collation_name

-- 檢視已有庫

show databases[ like 'pattern']

-- 檢視當前庫資訊

show create database 資料庫名

-- 修改庫的選項資訊

alter database 庫名 選項資訊

-- 刪除庫

drop database[ if exists] 資料庫名

同時刪除該資料庫相關的目錄及其目錄內容
/ 表的操作 / ------------------

-- 建立表

create [temporary] table[ if not exists] [庫名.]表名 ( 表的結構定義 )[ 表選項]

每個欄位必須有資料型別

最後一個欄位後不能有逗號

temporary 臨時表，會話結束時表自動消失

對於欄位的定義：

欄位名 資料型別 [NOT NULL | NULL] [DEFAULT default_value] [AUTO_INCREMENT] [UNIQUE [KEY] | [PRIMARY] KEY] [COMMENT 'string']

-- 表選項

-- 字符集

CHARSET = charset_name

如果表沒有設定，則使用資料庫字符集

-- 儲存引擎

ENGINE = engine_name

表在管理資料時採用的不同的資料結構，結構不同會導致處理方式、提供的特性操作等不同

常見的引擎：InnoDB MyISAM Memory/Heap BDB Merge Example CSV MaxDB Archive

不同的引擎在儲存表的結構和資料時採用不同的方式

MyISAM表文件含義：.frm表定義，.MYD表資料，.MYI表索引

InnoDB表文件含義：.frm表定義，表空間資料和日誌檔案

SHOW ENGINES -- 顯示儲存引擎的狀態資訊

SHOW ENGINE 引擎名 {LOGS|STATUS} -- 顯示儲存引擎的日誌或狀態資訊

-- 資料檔案目錄

DATA DIRECTORY = '目錄'

-- 索引檔案目錄

INDEX DIRECTORY = '目錄'

-- 表註釋

COMMENT = 'string'

-- 分割槽選項

PARTITION BY ... (詳細見手冊)

-- 檢視所有表

SHOW TABLES[ LIKE 'pattern']

SHOW TABLES FROM 表名

-- 查看錶機構

SHOW CREATE TABLE 表名    （資訊更詳細）

DESC 表名 / DESCRIBE 表名 / EXPLAIN 表名 / SHOW COLUMNS FROM 表名 [LIKE 'PATTERN']

SHOW TABLE STATUS [FROM db_name] [LIKE 'pattern']

-- 修改表

-- 修改表本身的選項

ALTER TABLE 表名 表的選項

EG:    ALTER TABLE 表名 ENGINE=MYISAM;

-- 對錶進行重新命名

RENAME TABLE 原表名 TO 新表名

RENAME TABLE 原表名 TO 庫名.表名    （可將表移動到另一個數據庫）

-- RENAME可以交換兩個表名

-- 修改表的欄位機構

ALTER TABLE 表名 操作名

-- 操作名

ADD[ COLUMN] 欄位名        -- 增加欄位

AFTER 欄位名            -- 表示增加在該欄位名後面

FIRST                -- 表示增加在第一個

ADD PRIMARY KEY(欄位名)    -- 建立主鍵

ADD UNIQUE [索引名] (欄位名)-- 建立唯一索引

ADD INDEX [索引名] (欄位名)    -- 建立普通索引

ADD

DROP[ COLUMN] 欄位名        -- 刪除欄位

MODIFY[ COLUMN] 欄位名 欄位屬性        -- 支援對欄位屬性進行修改，不能修改欄位名(所有原有屬性也需寫上)

CHANGE[ COLUMN] 原欄位名 新欄位名 欄位屬性        -- 支援對欄位名修改

DROP PRIMARY KEY    -- 刪除主鍵(刪除主鍵前需刪除其AUTO_INCREMENT屬性)

DROP INDEX 索引名    -- 刪除索引

DROP FOREIGN KEY 外來鍵    -- 刪除外來鍵
-- 刪除表

DROP TABLE[ IF EXISTS] 表名 ...

-- 清空表資料

TRUNCATE [TABLE] 表名

-- 複製表結構

CREATE TABLE 表名 LIKE 要複製的表名

-- 複製表結構和資料

CREATE TABLE 表名 [AS] SELECT * FROM 要複製的表名

-- 檢查表是否有錯誤

CHECK TABLE tbl_name [, tbl_name] ... [option] ...

-- 優化表

OPTIMIZE [LOCAL | NO_WRITE_TO_BINLOG] TABLE tbl_name [, tbl_name] ...

-- 修復表

REPAIR [LOCAL | NO_WRITE_TO_BINLOG] TABLE tbl_name [, tbl_name] ... [QUICK] [EXTENDED] [USE_FRM]

-- 分析表

ANALYZE [LOCAL | NO_WRITE_TO_BINLOG] TABLE tbl_name [, tbl_name] ...
/ 資料操作 / ------------------

-- 增

INSERT [INTO] 表名 [(欄位列表)] VALUES (值列表)[, (值列表), ...]

-- 如果要插入的值列表包含所有欄位並且順序一致，則可以省略欄位列表。

-- 可同時插入多條資料記錄！

REPLACE 與 INSERT 完全一樣，可互換。

INSERT [INTO] 表名 SET 欄位名=值[, 欄位名=值, ...]

-- 查

SELECT 欄位列表 FROM 表名[ 其他子句]

-- 可來自多個表的多個欄位

-- 其他子句可以不使用

-- 欄位列表可以用*代替，表示所有欄位

-- 刪

DELETE FROM 表名[ 刪除條件子句]

沒有條件子句，則會刪除全部

-- 改

UPDATE 表名 SET 欄位名=新值[, 欄位名=新值] [更新條件]
/ 字符集編碼 / ------------------

-- MySQL、資料庫、表、欄位均可設定編碼

-- 資料編碼與客戶端編碼不需一致

SHOW VARIABLES LIKE 'character_set_%'    -- 檢視所有字符集編碼項

    character_set_client        客戶端向伺服器傳送資料時使用的編碼

character_set_results        伺服器端將結果返回給客戶端所使用的編碼

character_set_connection    連線層編碼

SET 變數名 = 變數值

set character_set_client = gbk;

set character_set_results = gbk;

set character_set_connection = gbk;

SET NAMES GBK;    -- 相當於完成以上三個設定

-- 校對集

    校對集用以排序

SHOW CHARACTER SET [LIKE 'pattern']/SHOW CHARSET [LIKE 'pattern']    檢視所有字符集

SHOW COLLATION [LIKE 'pattern']        檢視所有校對集

charset 字符集編碼        設定字符集編碼

collate 校對集編碼        設定校對集編碼
/ 資料型別（列型別） / ------------------

1. 數值型別

-- a. 整型 ----------

    型別            位元組        範圍（有符號位）

tinyint        1位元組    -128 ~ 127        無符號位：0 ~ 255

smallint    2位元組    -32768 ~ 32767

mediumint    3位元組    -8388608 ~ 8388607

int            4位元組

bigint        8位元組
</span><span style="color: rgba(0, 0, 255, 1)">int</span><span style="color: rgba(0, 0, 0, 1)">(M)    M表示總位數
</span><span style="color: rgba(128, 128, 128, 1)">-</span><span style="color: rgba(0, 0, 0, 1)"> 預設存在符號位，unsigned 屬性修改
</span><span style="color: rgba(128, 128, 128, 1)">-</span><span style="color: rgba(0, 0, 0, 1)"> 顯示寬度，如果某個數不夠定義欄位時設定的位數，則前面以0補填，zerofill 屬性修改
    例：</span><span style="color: rgba(0, 0, 255, 1)">int</span>(<span style="color: rgba(128, 0, 0, 1); font-weight: bold">5</span>)    插入一個數<span style="color: rgba(255, 0, 0, 1)">'</span><span style="color: rgba(255, 0, 0, 1)">123</span><span style="color: rgba(255, 0, 0, 1)">'</span>，補填後為<span style="color: rgba(255, 0, 0, 1)">'</span><span style="color: rgba(255, 0, 0, 1)">00123</span><span style="color: rgba(255, 0, 0, 1)">'</span>
<span style="color: rgba(128, 128, 128, 1)">-</span><span style="color: rgba(0, 0, 0, 1)"> 在滿足要求的情況下，越小越好。
</span><span style="color: rgba(128, 128, 128, 1)">-</span> 1表示bool值真，0表示bool值假。MySQL沒有布林型別，通過整型0和1表示。常用tinyint(<span style="color: rgba(128, 0, 0, 1); font-weight: bold">1</span><span style="color: rgba(0, 0, 0, 1)">)表示布林型。

-- b. 浮點型 ----------

    型別                位元組        範圍

float(單精度)        4位元組

double(雙精度)    8位元組

浮點型既支援符號位 unsigned 屬性，也支援顯示寬度 zerofill 屬性。

不同於整型，前後均會補填0.

定義浮點型時，需指定總位數和小數位數。

float(M, D)        double(M, D)

M表示總位數，D表示小數位數。

M和D的大小會決定浮點數的範圍。不同於整型的固定範圍。

M既表示總位數（不包括小數點和正負號），也表示顯示寬度（所有顯示符號均包括）。

支援科學計數法表示。

浮點數表示近似值。
-- c. 定點數 ----------

decimal    -- 可變長度

decimal(M, D)    M也表示總位數，D表示小數位數。

儲存一個精確的數值，不會發生資料的改變，不同於浮點數的四捨五入。

將浮點數轉換為字串來儲存，每9位數字儲存為4個位元組。
2. 字串型別

-- a. char, varchar ----------

char    定長字串，速度快，但浪費空間

varchar    變長字串，速度慢，但節省空間

M表示能儲存的最大長度，此長度是字元數，非位元組數。

不同的編碼，所佔用的空間不同。

char,最多255個字元，與編碼無關。

varchar,最多65535字元，與編碼有關。

一條有效記錄最大不能超過65535個位元組。

utf8 最大為21844個字元，gbk 最大為32766個字元，latin1 最大為65532個字元

varchar 是變長的，需要利用儲存空間儲存 varchar 的長度，如果資料小於255個位元組，則採用一個位元組來儲存長度，反之需要兩個位元組來儲存。

varchar 的最大有效長度由最大行大小和使用的字符集確定。

最大有效長度是65532位元組，因為在varchar存字串時，第一個位元組是空的，不存在任何資料，然後還需兩個位元組來存放字串的長度，所以有效長度是64432-1-2=65532位元組。

例：若一個表定義為 CREATE TABLE tb(c1 int, c2 char(30), c3 varchar(N)) charset=utf8; 問N的最大值是多少？ 答：(65535-1-2-4-30*3)/3
-- b. blob, text ----------

    blob 二進位制字串（位元組字串）

tinyblob, blob, mediumblob, longblob

text 非二進位制字串（字元字串）

tinytext, text, mediumtext, longtext

text 在定義時，不需要定義長度，也不會計算總長度。

text 型別在定義時，不可給default值
-- c. binary, varbinary ----------

    類似於char和varchar，用於儲存二進位制字串，也就是儲存位元組字串而非字元字串。

char, varchar, text 對應 binary, varbinary, blob.
3. 日期時間型別

一般用整型儲存時間戳，因為PHP可以很方便的將時間戳進行格式化。

datetime    8位元組    日期及時間        1000-01-01 00:00:00 到 9999-12-31 23:59:59

date        3位元組    日期            1000-01-01 到 9999-12-31

timestamp    4位元組    時間戳        19700101000000 到 2038-01-19 03:14:07

time        3位元組    時間            -838:59:59 到 838:59:59

year        1位元組    年份            1901 - 2155
datetime    “YYYY-MM-DD hh:mm:ss”

timestamp    “YY-MM-DD hh:mm:ss”

“YYYYMMDDhhmmss”

“YYMMDDhhmmss”

YYYYMMDDhhmmss

YYMMDDhhmmss

date        “YYYY-MM-DD”

“YY-MM-DD”

“YYYYMMDD”

“YYMMDD”

YYYYMMDD

YYMMDD

time        “hh:mm:ss”

“hhmmss”

hhmmss

year        “YYYY”

“YY”

YYYY

YY
4. 列舉和集合

-- 列舉(enum) ----------

enum(val1, val2, val3...)

在已知的值中進行單選。最大數量為65535.

列舉值在儲存時，以2個位元組的整型(smallint)儲存。每個列舉值，按儲存的位置順序，從1開始逐一遞增。

表現為字串型別，儲存卻是整型。

NULL值的索引是NULL。

空字串錯誤值的索引值是0。
-- 集合（set） ----------

set(val1, val2, val3...)

create table tab ( gender set('男', '女', '無') );

insert into tab values ('男, 女');

最多可以有64個不同的成員。以bigint儲存，共8個位元組。採取位運算的形式。

當建立表時，SET成員值的尾部空格將自動被刪除。
/ 選擇型別 /

-- PHP角度

1. 功能滿足

2. 儲存空間儘量小，處理效率更高

3. 考慮相容問題
-- IP儲存 ----------

1. 只需儲存，可用字串

2. 如果需計算，查詢等，可儲存為4個位元組的無符號int，即unsigned

1) PHP函式轉換

ip2long可轉換為整型，但會出現攜帶符號問題。需格式化為無符號的整型。

利用sprintf函式格式化字串

sprintf("%u", ip2long('192.168.3.134'));

然後用long2ip將整型轉回IP字串

2) MySQL函式轉換(無符號整型，UNSIGNED)

INET_ATON('127.0.0.1') 將IP轉為整型

INET_NTOA(2130706433) 將整型轉為IP
/ 列屬性（列約束） / ------------------

1. 主鍵

- 能唯一標識記錄的欄位，可以作為主鍵。

- 一個表只能有一個主鍵。

- 主鍵具有唯一性。

- 宣告欄位時，用 primary key 標識。

也可以在欄位列表之後宣告

例：create table tab ( id int, stu varchar(10), primary key (id));

- 主鍵欄位的值不能為null。

- 主鍵可以由多個欄位共同組成。此時需要在欄位列表後宣告的方法。

例：create table tab ( id int, stu varchar(10), age int, primary key (stu, age));
2. unique 唯一索引（唯一約束）

使得某欄位的值也不能重複。
3. null 約束

null不是資料型別，是列的一個屬性。

表示當前列是否可以為null，表示什麼都沒有。

null, 允許為空。預設。

not null, 不允許為空。

insert into tab values (null, 'val');

-- 此時表示將第一個欄位的值設為null, 取決於該欄位是否允許為null
4. default 預設值屬性

當前欄位的預設值。

insert into tab values (default, 'val');    -- 此時表示強制使用預設值。

create table tab ( add_time timestamp default current_timestamp );

-- 表示將當前時間的時間戳設為預設值。

current_date, current_time
5. auto_increment 自動增長約束

自動增長必須為索引（主鍵或unique）

只能存在一個欄位為自動增長。

預設為1開始自動增長。可以通過表屬性 auto_increment = x進行設定，或 alter table tbl auto_increment = x;
6. comment 註釋

例：create table tab ( id int ) comment '註釋內容';
7. foreign key 外來鍵約束

用於限制主表與從表資料完整性。

alter table t1 add constraint t1_t2_fk foreign key (t1_id) references t2(id);

-- 將表t1的t1_id外來鍵關聯到表t2的id欄位。

-- 每個外來鍵都有一個名字，可以通過 constraint 指定



存在外來鍵的表，稱之為從表（子表），外來鍵指向的表，稱之為主表（父表）。
作用：保持資料一致性，完整性，主要目的是控制儲存在外來鍵表（從表）中的資料。

MySQL中，可以對InnoDB引擎使用外來鍵約束：
語法：
</span><span style="color: rgba(0, 0, 255, 1)">foreign</span> <span style="color: rgba(0, 0, 255, 1)">key</span> (外來鍵欄位） <span style="color: rgba(0, 0, 255, 1)">references</span> 主表名 (關聯欄位) <span style="color: rgba(255, 0, 0, 1)">[</span><span style="color: rgba(255, 0, 0, 1)">主表記錄刪除時的動作</span><span style="color: rgba(255, 0, 0, 1)">]</span> <span style="color: rgba(255, 0, 0, 1)">[</span><span style="color: rgba(255, 0, 0, 1)">主表記錄更新時的動作</span><span style="color: rgba(255, 0, 0, 1)">]</span><span style="color: rgba(0, 0, 0, 1)">
此時需要檢測一個從表的外來鍵需要約束為主表的已存在的值。外來鍵在沒有關聯的情況下，可以設定為null.前提是該外來鍵列，沒有not </span><span style="color: rgba(0, 0, 255, 1)">null</span><span style="color: rgba(0, 0, 0, 1)">。

可以不指定主表記錄更改或更新時的動作，那麼此時主表的操作被拒絕。
如果指定了 </span><span style="color: rgba(0, 0, 255, 1)">on</span> <span style="color: rgba(0, 0, 255, 1)">update</span> 或 <span style="color: rgba(0, 0, 255, 1)">on</span> <span style="color: rgba(0, 0, 255, 1)">delete</span><span style="color: rgba(0, 0, 0, 1)">：在刪除或更新時，有如下幾個操作可以選擇：
</span><span style="color: rgba(128, 0, 0, 1); font-weight: bold">1</span>. <span style="color: rgba(0, 0, 255, 1)">cascade</span><span style="color: rgba(0, 0, 0, 1)">，級聯操作。主表資料被更新（主鍵值更新），從表也被更新（外來鍵值更新）。主表記錄被刪除，從表相關記錄也被刪除。
</span><span style="color: rgba(128, 0, 0, 1); font-weight: bold">2</span>. <span style="color: rgba(0, 0, 255, 1)">set</span> <span style="color: rgba(0, 0, 255, 1)">null</span><span style="color: rgba(0, 0, 0, 1)">，設定為null。主表資料被更新（主鍵值更新），從表的外來鍵被設定為null。主表記錄被刪除，從表相關記錄外來鍵被設定成null。但注意，要求該外來鍵列，沒有not null屬性約束。
</span><span style="color: rgba(128, 0, 0, 1); font-weight: bold">3</span>. <span style="color: rgba(0, 0, 255, 1)">restrict</span><span style="color: rgba(0, 0, 0, 1)">，拒絕父表刪除和更新。

注意，外來鍵只被InnoDB儲存引擎所支援。其他引擎是不支援的。

/ 建表規範 / ------------------

-- Normal Format, NF

- 每個表儲存一個實體資訊

- 每個具有一個ID欄位作為主鍵

- ID主鍵 + 原子表

-- 1NF, 第一正規化

        欄位不能再分，就滿足第一正規化。

-- 2NF, 第二正規化

        滿足第一正規化的前提下，不能出現部分依賴。

消除符合主鍵就可以避免部分依賴。增加單列關鍵字。

-- 3NF, 第三正規化

        滿足第二正規化的前提下，不能出現傳遞依賴。

某個欄位依賴於主鍵，而有其他欄位依賴於該欄位。這就是傳遞依賴。

將一個實體資訊的資料放在一個表內實現。
/ select / ------------------
select [all|distinct] select_expr from -> where -> group by [合計函式] -> having -> order by -> limit
a. select_expr

-- 可以用 * 表示所有欄位。

select * from tb;

-- 可以使用表示式（計算公式、函式呼叫、欄位也是個表示式）

select stu, 29+25, now() from tb;

-- 可以為每個列使用別名。適用於簡化列標識，避免多個列識別符號重複。

- 使用 as 關鍵字，也可省略 as.

select stu+10 as add10 from tb;
b. from 子句

用於標識查詢來源。

-- 可以為表起別名。使用as關鍵字。

select  from tb1 as tt, tb2 as bb;

-- from子句後，可以同時出現多個表。

-- 多個表會橫向疊加到一起，而資料會形成一個笛卡爾積。

select  from tb1, tb2;
c. where 子句

-- 從from獲得的資料來源中進行篩選。

-- 整型1表示真，0表示假。

-- 表示式由運算子和運算陣列成。

-- 運算數：變數（欄位）、值、函式返回值

-- 運算子：

=, <=>, <>, !=, <=, <, >=, >, !, &&, ||,

in (not) null, (not) like, (not) in, (not) between and, is (not), and, or, not, xor

is/is not 加上ture/false/unknown，檢驗某個值的真假

<=>與<>功能相同，<=>可用於null比較
d. group by 子句, 分組子句

group by 欄位/別名 [排序方式]

分組後會進行排序。升序：ASC，降序：DESC
以下</span><span style="color: rgba(255, 0, 0, 1)">[</span><span style="color: rgba(255, 0, 0, 1)">合計函式</span><span style="color: rgba(255, 0, 0, 1)">]</span>需配合 <span style="color: rgba(0, 0, 255, 1)">group</span> <span style="color: rgba(0, 0, 255, 1)">by</span><span style="color: rgba(0, 0, 0, 1)"> 使用：
</span><span style="color: rgba(255, 0, 255, 1)">count</span> 返回不同的非NULL值數目    <span style="color: rgba(255, 0, 255, 1)">count</span>(<span style="color: rgba(128, 128, 128, 1)">*</span>)、<span style="color: rgba(255, 0, 255, 1)">count</span><span style="color: rgba(0, 0, 0, 1)">(欄位)
</span><span style="color: rgba(255, 0, 255, 1)">sum</span><span style="color: rgba(0, 0, 0, 1)"> 求和
</span><span style="color: rgba(255, 0, 255, 1)">max</span><span style="color: rgba(0, 0, 0, 1)"> 求最大值
</span><span style="color: rgba(255, 0, 255, 1)">min</span><span style="color: rgba(0, 0, 0, 1)"> 求最小值
</span><span style="color: rgba(255, 0, 255, 1)">avg</span><span style="color: rgba(0, 0, 0, 1)"> 求平均值
group_concat 返回帶有來自一個組的連線的非NULL值的字串結果。組內字串連線。

e. having 子句，條件子句

與 where 功能、用法相同，執行時機不同。

where 在開始時執行檢測資料，對原資料進行過濾。

having 對篩選出的結果再次進行過濾。

having 欄位必須是查詢出來的，where 欄位必須是資料表存在的。

where 不可以使用欄位的別名，having 可以。因為執行WHERE程式碼時，可能尚未確定列值。

where 不可以使用合計函式。一般需用合計函式才會用 having

SQL標準要求HAVING必須引用GROUP BY子句中的列或用於合計函式中的列。
f. order by 子句，排序子句

order by 排序欄位/別名 排序方式 [,排序欄位/別名 排序方式]...

升序：ASC，降序：DESC

支援多個欄位的排序。
g. limit 子句，限制結果數量子句

僅對處理好的結果進行數量限制。將處理好的結果的看作是一個集合，按照記錄出現的順序，索引從0開始。

limit 起始位置, 獲取條數

省略第一個引數，表示從索引0開始。limit 獲取條數
h. distinct, all 選項

distinct 去除重複記錄

預設為 all, 全部記錄
/ UNION / ------------------

    將多個select查詢的結果組合成一個結果集合。

SELECT ... UNION [ALL|DISTINCT] SELECT ...

預設 DISTINCT 方式，即所有返回的行都是唯一的

建議，對每個SELECT查詢加上小括號包裹。

ORDER BY 排序時，需加上 LIMIT 進行結合。

需要各select查詢的欄位數量一樣。

每個select查詢的欄位列表(數量、型別)應一致，因為結果中的欄位名以第一條select語句為準。
/ 子查詢 / ------------------

- 子查詢需用括號包裹。

-- from型

    from後要求是一個表，必須給子查詢結果取個別名。

- 簡化每個查詢內的條件。

- from型需將結果生成一個臨時表格，可用以原表的鎖定的釋放。

- 子查詢返回一個表，表型子查詢。

select  from (select  from tb where id>0) as subfrom where id>1;

-- where型

- 子查詢返回一個值，標量子查詢。

- 不需要給子查詢取別名。

- where子查詢內的表，不能直接用以更新。

select  from tb where money = (select max(money) from tb);

-- 列子查詢

        如果子查詢結果返回的是一列。

使用 in 或 not in 完成查詢

exists 和 not exists 條件

如果子查詢返回資料，則返回1或0。常用於判斷條件。

select column1 from t1 where exists (select  from t2);

-- 行子查詢

        查詢條件是一個行。

select * from t1 where (id, gender) in (select id, gender from t2);

行構造符：(col1, col2, ...) 或 ROW(col1, col2, ...)

行構造符通常用於與對能返回兩個或兩個以上列的子查詢進行比較。
</span><span style="color: rgba(0, 128, 128, 1)">--</span><span style="color: rgba(0, 128, 128, 1)"> 特殊運算子</span>
<span style="color: rgba(128, 128, 128, 1)">!=</span> <span style="color: rgba(128, 128, 128, 1)">all</span>()    相當於 <span style="color: rgba(128, 128, 128, 1)">not</span> <span style="color: rgba(128, 128, 128, 1)">in</span>
<span style="color: rgba(128, 128, 128, 1)">=</span> <span style="color: rgba(128, 128, 128, 1)">some</span>()    相當於 <span style="color: rgba(128, 128, 128, 1)">in</span>。<span style="color: rgba(128, 128, 128, 1)">any</span> 是 <span style="color: rgba(128, 128, 128, 1)">some</span><span style="color: rgba(0, 0, 0, 1)"> 的別名
</span><span style="color: rgba(128, 128, 128, 1)">!=</span> <span style="color: rgba(128, 128, 128, 1)">some</span>()    不等同於 <span style="color: rgba(128, 128, 128, 1)">not</span> <span style="color: rgba(128, 128, 128, 1)">in</span><span style="color: rgba(0, 0, 0, 1)">，不等於其中某一個。
</span><span style="color: rgba(128, 128, 128, 1)">all</span>, <span style="color: rgba(128, 128, 128, 1)">some</span><span style="color: rgba(0, 0, 0, 1)"> 可以配合其他運算子一起使用。

/ 連線查詢(join) / ------------------

    將多個表的欄位進行連線，可以指定連線條件。

-- 內連線(inner join)

- 預設就是內連線，可省略inner。

- 只有資料存在時才能傳送連線。即連線結果不能出現空行。

on 表示連線條件。其條件表示式與where類似。也可以省略條件（表示條件永遠為真）

也可用where表示連線條件。

還有 using, 但需欄位名相同。 using(欄位名)
</span><span style="color: rgba(0, 128, 128, 1)">--</span><span style="color: rgba(0, 128, 128, 1)"> 交叉連線 cross join</span>

        即，沒有條件的內連線。

select * from tb1 cross join tb2;

-- 外連線(outer join)

- 如果資料不存在，也會出現在連線結果中。

-- 左外連線 left join

        如果資料不存在，左表記錄會出現，而右表為null填充

-- 右外連線 right join

        如果資料不存在，右表記錄會出現，而左表為null填充

-- 自然連線(natural join)

    自動判斷連線條件完成連線。

相當於省略了using，會自動查詢相同欄位名。

natural join

natural left join

natural right join
select info.id, info.name, info.stu_num, extra_info.hobby, extra_info.sex from info, extra_info where info.stu_num = extra_info.stu_id;
/ 匯入匯出 / ------------------

select * into outfile 檔案地址 [控制格式] from 表名;    -- 匯出表資料

load data [local] infile 檔案地址 [replace|ignore] into table 表名 [控制格式];    -- 匯入資料

    生成的資料預設的分隔符是製表符

local未指定，則資料檔案必須在伺服器上

replace 和 ignore 關鍵詞控制對現有的唯一鍵記錄的重複的處理

-- 控制格式

fields    控制欄位格式

預設：fields terminated by '\t' enclosed by '' escaped by '\'

terminated by 'string'    -- 終止

enclosed by 'char'        -- 包裹

escaped by 'char'        -- 轉義

-- 示例：

SELECT a,b,a+b INTO OUTFILE '/tmp/result.text'

FIELDS TERMINATED BY ',' OPTIONALLY ENCLOSED BY '"'

LINES TERMINATED BY '\n'

FROM test_table;

lines    控制行格式

預設：lines terminated by '\n'

terminated by 'string'    -- 終止
/ insert / ------------------

select語句獲得的資料可以用insert插入。
可以省略對列的指定，要求 values () 括號內，提供給了按照列順序出現的所有欄位的值。

或者使用set語法。

insert into tbl_name set field=value,...；
可以一次性使用多個值，採用(), (), ();的形式。

insert into tbl_name values (), (), ();
可以在列值指定時，使用表示式。

insert into tbl_name values (field_value, 10+10, now());

可以使用一個特殊值 default，表示該列使用預設值。

insert into tbl_name values (field_value, default);
可以通過一個查詢的結果，作為需要插入的值。

insert into tbl_name select ...;
可以指定在插入的值出現主鍵（或唯一索引）衝突時，更新其他非主鍵列的資訊。

insert into tbl_name values/set/select on duplicate key update 欄位=值, …;
/ delete / ------------------

DELETE FROM tbl_name [WHERE where_definition] [ORDER BY ...] [LIMIT row_count]
按照條件刪除
指定刪除的最多記錄數。Limit
可以通過排序條件刪除。order by + limit
支援多表刪除，使用類似連線語法。

delete from 需要刪除資料多表1，表2 using 表連線操作 條件。
/ truncate / ------------------

TRUNCATE [TABLE] tbl_name

清空資料

刪除重建表
區別：

1，truncate 是刪除表再建立，delete 是逐條刪除

2，truncate 重置auto_increment的值。而delete不會

3，truncate 不知道刪除了幾條，而delete知道。

4，當被用於帶分割槽的表時，truncate 會保留分割槽
/ 備份與還原 / ------------------

備份，將資料的結構與表內資料儲存起來。

利用 mysqldump 指令完成。
-- 匯出

1. 匯出一張表

　　mysqldump -u使用者名稱 -p密碼 庫名 表名 > 檔名(D:/a.sql)

2. 匯出多張表

　　mysqldump -u使用者名稱 -p密碼 庫名 表1 表2 表3 > 檔名(D:/a.sql)

3. 匯出所有表

　　mysqldump -u使用者名稱 -p密碼 庫名 > 檔名(D:/a.sql)

4. 匯出一個庫

　　mysqldump -u使用者名稱 -p密碼 -B 庫名 > 檔名(D:/a.sql)
可以-w攜帶備份條件
-- 匯入

1. 在登入mysql的情況下：

　　source  備份檔案

2. 在不登入的情況下

　　mysql -u使用者名稱 -p密碼 庫名 < 備份檔案
/ 檢視 / ------------------

什麼是檢視：

檢視是一個虛擬表，其內容由查詢定義。同真實的表一樣，檢視包含一系列帶有名稱的列和行資料。但是，檢視並不在資料庫中以儲存的資料值集形式存在。行和列資料來自由定義檢視的查詢所引用的表，並且在引用檢視時動態生成。

檢視具有表結構檔案，但不存在資料檔案。

對其中所引用的基礎表來說，檢視的作用類似於篩選。定義檢視的篩選可以來自當前或其它資料庫的一個或多個表，或者其它檢視。通過檢視進行查詢沒有任何限制，通過它們進行資料修改時的限制也很少。

檢視是儲存在資料庫中的查詢的sql語句，它主要出於兩種原因：安全原因，檢視可以隱藏一些資料，如：社會保險基金錶，可以用檢視只顯示姓名，地址，而不顯示社會保險號和工資數等，另一原因是可使複雜的查詢易於理解和使用。
-- 建立檢視

CREATE [OR REPLACE] [ALGORITHM = {UNDEFINED | MERGE | TEMPTABLE}] VIEW view_name [(column_list)] AS select_statement

- 檢視名必須唯一，同時不能與表重名。

- 檢視可以使用select語句查詢到的列名，也可以自己指定相應的列名。

- 可以指定檢視執行的演算法，通過ALGORITHM指定。

- column_list如果存在，則數目必須等於SELECT語句檢索的列數
-- 檢視結構

SHOW CREATE VIEW view_name
-- 刪除檢視

- 刪除檢視後，資料依然存在。

- 可同時刪除多個檢視。

DROP VIEW [IF EXISTS] view_name ...
-- 修改檢視結構

- 一般不修改檢視，因為不是所有的更新檢視都會對映到表上。

ALTER VIEW view_name [(column_list)] AS select_statement
-- 檢視作用

1. 簡化業務邏輯

2. 對客戶端隱藏真實的表結構
-- 檢視演算法(ALGORITHM)

    MERGE        合併

將檢視的查詢語句，與外部查詢需要先合併再執行！

TEMPTABLE    臨時表

將檢視執行完畢後，形成臨時表，再做外層查詢！

UNDEFINED    未定義(預設)，指的是MySQL自主去選擇相應的演算法。
/ 事務(transaction) / ------------------

事務是指邏輯上的一組操作，組成這組操作的各個單元，要不全成功要不全失敗。

- 支援連續SQL的集體成功或集體撤銷。

- 事務是資料庫在資料晚自習方面的一個功能。

- 需要利用 InnoDB 或 BDB 儲存引擎，對自動提交的特性支援完成。

- InnoDB被稱為事務安全型引擎。
-- 事務開啟

START TRANSACTION; 或者 BEGIN;

開啟事務後，所有被執行的SQL語句均被認作當前事務內的SQL語句。

-- 事務提交

COMMIT;

-- 事務回滾

ROLLBACK;

如果部分操作發生問題，對映到事務開啟前。
-- 事務的特性

1. 原子性（Atomicity）

事務是一個不可分割的工作單位，事務中的操作要麼都發生，要麼都不發生。

2. 一致性（Consistency）

事務前後資料的完整性必須保持一致。

- 事務開始和結束時，外部資料一致

- 在整個事務過程中，操作是連續的

3. 隔離性（Isolation）

多個使用者併發訪問資料庫時，一個使用者的事務不能被其它使用者的事物所幹擾，多個併發事務之間的資料要相互隔離。

4. 永續性（Durability）

一個事務一旦被提交，它對資料庫中的資料改變就是永久性的。
-- 事務的實現

1. 要求是事務支援的表型別

2. 執行一組相關的操作前開啟事務

3. 整組操作完成後，都成功，則提交；如果存在失敗，選擇回滾，則會回到事務開始的備份點。
-- 事務的原理

    利用InnoDB的自動提交(autocommit)特性完成。

普通的MySQL執行語句後，當前的資料提交操作均可被其他客戶端可見。

而事務是暫時關閉“自動提交”機制，需要commit提交持久化資料操作。
-- 注意

1. 資料定義語言（DDL）語句不能被回滾，比如建立或取消資料庫的語句，和建立、取消或更改表或儲存的子程式的語句。

2. 事務不能被巢狀
-- 儲存點

SAVEPOINT 儲存點名稱 -- 設定一個事務儲存點

ROLLBACK TO SAVEPOINT 儲存點名稱 -- 回滾到儲存點

RELEASE SAVEPOINT 儲存點名稱 -- 刪除儲存點
-- InnoDB自動提交特性設定

SET autocommit = 0|1;    0表示關閉自動提交，1表示開啟自動提交。

- 如果關閉了，那普通操作的結果對其他客戶端也不可見，需要commit提交後才能持久化資料操作。

- 也可以關閉自動提交來開啟事務。但與START TRANSACTION不同的是，

SET autocommit是永久改變伺服器的設定，直到下次再次修改該設定。(針對當前連線)

而START TRANSACTION記錄開啟前的狀態，而一旦事務提交或回滾後就需要再次開啟事務。(針對當前事務)
/ 鎖表 /

表鎖定只用於防止其它客戶端進行不正當地讀取和寫入

MyISAM 支援表鎖，InnoDB 支援行鎖

-- 鎖定

LOCK TABLES tbl_name [AS alias]

-- 解鎖

    UNLOCK TABLES
/ 觸發器 / ------------------

    觸發程式是與表有關的命名資料庫物件，當該表出現特定事件時，將啟用該物件

監聽：記錄的增加、修改、刪除。
-- 建立觸發器

CREATE TRIGGER trigger_name trigger_time trigger_event ON tbl_name FOR EACH ROW trigger_stmt

引數：

trigger_time是觸發程式的動作時間。它可以是 before 或 after，以指明觸發程式是在啟用它的語句之前或之後觸發。

trigger_event指明瞭啟用觸發程式的語句的型別

INSERT：將新行插入表時啟用觸發程式

UPDATE：更改某一行時啟用觸發程式

DELETE：從表中刪除某一行時啟用觸發程式

tbl_name：監聽的表，必須是永久性的表，不能將觸發程式與TEMPORARY表或檢視關聯起來。

trigger_stmt：當觸發程式啟用時執行的語句。執行多個語句，可使用BEGIN...END複合語句結構
-- 刪除

DROP TRIGGER [schema_name.]trigger_name
可以使用old和new代替舊的和新的資料

更新操作，更新前是old，更新後是new.

刪除操作，只有old.

增加操作，只有new.
-- 注意

1. 對於具有相同觸發程式動作時間和事件的給定表，不能有兩個觸發程式。
-- 字元連線函式

concat(str1[, str2,...])
-- 分支語句

if 條件 then

執行語句

elseif 條件 then

執行語句

else

執行語句

end if;
-- 修改最外層語句結束符

delimiter 自定義結束符號

SQL語句

自定義結束符號
delimiter ;        -- 修改回原來的分號
-- 語句塊包裹

begin

語句塊

end
-- 特殊的執行

1. 只要新增記錄，就會觸發程式。

2. Insert into on duplicate key update 語法會觸發：

如果沒有重複記錄，會觸發 before insert, after insert;

如果有重複記錄並更新，會觸發 before insert, before update, after update;

如果有重複記錄但是沒有發生更新，則觸發 before insert, before update

3. Replace 語法 如果有記錄，則執行 before insert, before delete, after delete, after insert
/ SQL程式設計 / ------------------
--// 區域性變數 ----------

-- 變數宣告

declare var_name[,...] type [default value]

這個語句被用來宣告區域性變數。要給變數提供一個預設值，請包含一個default子句。值可以被指定為一個表示式，不需要為一個常數。如果沒有default子句，初始值為null。
-- 賦值

使用 set 和 select into 語句為變數賦值。
</span><span style="color: rgba(128, 128, 128, 1)">-</span><span style="color: rgba(0, 0, 0, 1)"> 注意：在函式內是可以使用全域性變數（使用者自定義的變數）

--// 全域性變數 ----------

-- 定義、賦值

set 語句可以定義併為變數賦值。

set @var = value;

也可以使用select into語句為變數初始化並賦值。這樣要求select語句只能返回一行，但是可以是多個欄位，就意味著同時為多個變數進行賦值，變數的數量需要與查詢的列數一致。

還可以把賦值語句看作一個表示式，通過select執行完成。此時為了避免=被當作關係運算符看待，使用:=代替。（set語句可以使用= 和 :=）。

select @var:=20;

select @v1:=id, @v2=name from t1 limit 1;

select * from tbl_name where @var:=30;
select into 可以將表中查詢獲得的資料賦給變數。

-| select max(height) into @max_height from tb;
-- 自定義變數名

為了避免select語句中，使用者自定義的變數與系統識別符號（通常是欄位名）衝突，使用者自定義變數在變數名前使用@作為開始符號。

@var=10;
</span><span style="color: rgba(128, 128, 128, 1)">-</span><span style="color: rgba(0, 0, 0, 1)"> 變數被定義後，在整個會話週期都有效（登入到退出）

--// 控制結構 ----------

-- if語句

if search_condition then

statement_list

[elseif search_condition then

statement_list]

...

[else

statement_list]

end if;
-- case語句

CASE value WHEN [compare-value] THEN result

[WHEN [compare-value] THEN result ...]

[ELSE result]

END
-- while迴圈

[begin_label:] while search_condition do

statement_list

end while [end_label];
- 如果需要在迴圈內提前終止 while迴圈，則需要使用標籤；標籤需要成對出現。
</span><span style="color: rgba(0, 128, 128, 1)">--</span><span style="color: rgba(0, 128, 128, 1)"> 退出迴圈</span>

        退出整個迴圈 leave

退出當前迴圈 iterate

通過退出的標籤決定退出哪個迴圈
--// 內建函式 ----------

-- 數值函式

abs(x)            -- 絕對值 abs(-10.9) = 10

format(x, d)    -- 格式化千分位數值 format(1234567.456, 2) = 1,234,567.46

ceil(x)            -- 向上取整 ceil(10.1) = 11

floor(x)        -- 向下取整 floor (10.1) = 10

round(x)        -- 四捨五入去整

mod(m, n)        -- m%n m mod n 求餘 10%3=1

pi()            -- 獲得圓周率

pow(m, n)        -- m^n

sqrt(x)            -- 算術平方根

rand()            -- 隨機數

truncate(x, d)    -- 擷取d位小數
-- 時間日期函式

now(), current_timestamp();     -- 當前日期時間

current_date();                    -- 當前日期

current_time();                    -- 當前時間

date('yyyy-mm-dd hh:ii:ss');    -- 獲取日期部分

time('yyyy-mm-dd hh:ii:ss');    -- 獲取時間部分

date_format('yyyy-mm-dd hh:ii:ss', '%d %y %a %d %m %b %j');    -- 格式化時間

unix_timestamp();                -- 獲得unix時間戳

from_unixtime();                -- 從時間戳獲得時間
-- 字串函式

length(string)            -- string長度，位元組

char_length(string)        -- string的字元個數

substring(str, position [,length])        -- 從str的position開始,取length個字元

replace(str ,search_str ,replace_str)    -- 在str中用replace_str替換search_str

instr(string ,substring)    -- 返回substring首次在string中出現的位置

concat(string [,...])    -- 連線字串

charset(str)            -- 返回字串字符集

lcase(string)            -- 轉換成小寫

left(string, length)    -- 從string2中的左邊起取length個字元

load_file(file_name)    -- 從檔案讀取內容

locate(substring, string [,start_position])    -- 同instr,但可指定開始位置

lpad(string, length, pad)    -- 重複用pad加在string開頭,直到字串長度為length

ltrim(string)            -- 去除前端空格

repeat(string, count)    -- 重複count次

rpad(string, length, pad)    --在str後用pad補充,直到長度為length

rtrim(string)            -- 去除後端空格

strcmp(string1 ,string2)    -- 逐字元比較兩字串大小
-- 流程函式

case when [condition] then result [when [condition] then result ...] [else result] end   多分支

if(expr1,expr2,expr3)  雙分支。
-- 聚合函式

count()

sum();

max();

min();

avg();

group_concat()
-- 其他常用函式

md5();

default();
--// 儲存函式，自定義函式 ----------

-- 新建

CREATE FUNCTION function_name (引數列表) RETURNS 返回值型別

函式體
</span><span style="color: rgba(128, 128, 128, 1)">-</span><span style="color: rgba(0, 0, 0, 1)"> 函式名，應該合法的識別符號，並且不應該與已有的關鍵字衝突。
</span><span style="color: rgba(128, 128, 128, 1)">-</span><span style="color: rgba(0, 0, 0, 1)"> 一個函式應該屬於某個資料庫，可以使用db_name.funciton_name的形式執行當前函式所屬資料庫，否則為當前資料庫。
</span><span style="color: rgba(128, 128, 128, 1)">-</span><span style="color: rgba(0, 0, 0, 1)"> 引數部分，由"引數名"和"引數型別"組成。多個引數用逗號隔開。
</span><span style="color: rgba(128, 128, 128, 1)">-</span><span style="color: rgba(0, 0, 0, 1)"> 函式體由多條可用的mysql語句，流程控制，變數宣告等語句構成。
</span><span style="color: rgba(128, 128, 128, 1)">-</span> 多條語句應該使用 <span style="color: rgba(0, 0, 255, 1)">begin</span>...<span style="color: rgba(0, 0, 255, 1)">end</span><span style="color: rgba(0, 0, 0, 1)"> 語句塊包含。
</span><span style="color: rgba(128, 128, 128, 1)">-</span> 一定要有 <span style="color: rgba(0, 0, 255, 1)">return</span><span style="color: rgba(0, 0, 0, 1)"> 返回值語句。

-- 刪除

DROP FUNCTION [IF EXISTS] function_name;
-- 檢視

SHOW FUNCTION STATUS LIKE 'partten'

SHOW CREATE FUNCTION function_name;
-- 修改

ALTER FUNCTION function_name 函式選項
--// 儲存過程，自定義功能 ----------

-- 定義

儲存儲存過程 是一段程式碼（過程），儲存在資料庫中的sql組成。

一個儲存過程通常用於完成一段業務邏輯，例如報名，交班費，訂單入庫等。

而一個函式通常專注與某個功能，視為其他程式服務的，需要在其他語句中呼叫函式才可以，而儲存過程不能被其他呼叫，是自己執行 通過call執行。
-- 建立

CREATE PROCEDURE sp_name (引數列表)

過程體
引數列表：不同於函式的引數列表，需要指明引數型別

IN，表示輸入型

OUT，表示輸出型

INOUT，表示混合型
注意，沒有返回值。
/ 儲存過程 / ------------------

儲存過程是一段可執行性程式碼的集合。相比函式，更偏向於業務邏輯。

呼叫：CALL 過程名

-- 注意

- 沒有返回值。

- 只能單獨呼叫，不可夾雜在其他語句中
-- 引數

IN|OUT|INOUT 引數名 資料型別

IN        輸入：在呼叫過程中，將資料輸入到過程體內部的引數

OUT        輸出：在呼叫過程中，將過程體處理完的結果返回到客戶端

INOUT    輸入輸出：既可輸入，也可輸出
-- 語法

CREATE PROCEDURE 過程名 (引數列表)

BEGIN

過程體

END
/ 使用者和許可權管理 / ------------------

使用者資訊表：mysql.user

-- 重新整理許可權

FLUSH PRIVILEGES

-- 增加使用者

CREATE USER 使用者名稱 IDENTIFIED BY [PASSWORD] 密碼(字串)

- 必須擁有mysql資料庫的全域性CREATE USER許可權，或擁有INSERT許可權。

- 只能建立使用者，不能賦予許可權。

- 使用者名稱，注意引號：如 'user_name'@'192.168.1.1'

- 密碼也需引號，純數字密碼也要加引號

- 要在純文字中指定密碼，需忽略PASSWORD關鍵詞。要把密碼指定為由PASSWORD()函式返回的混編值，需包含關鍵字PASSWORD

-- 重新命名使用者

RENAME USER old_user TO new_user

-- 設定密碼

SET PASSWORD = PASSWORD('密碼')    -- 為當前使用者設定密碼

SET PASSWORD FOR 使用者名稱 = PASSWORD('密碼')    -- 為指定使用者設定密碼

-- 刪除使用者

DROP USER 使用者名稱

-- 分配許可權/新增使用者

GRANT 許可權列表 ON 表名 TO 使用者名稱 [IDENTIFIED BY [PASSWORD] 'password']

- all privileges 表示所有許可權

- . 表示所有庫的所有表

- 庫名.表名 表示某庫下面的某表

-- 檢視許可權

SHOW GRANTS FOR 使用者名稱

-- 檢視當前使用者許可權

SHOW GRANTS; 或 SHOW GRANTS FOR CURRENT_USER; 或 SHOW GRANTS FOR CURRENT_USER();

-- 撤消許可權

REVOKE 許可權列表 ON 表名 FROM 使用者名稱

REVOKE ALL PRIVILEGES, GRANT OPTION FROM 使用者名稱    -- 撤銷所有許可權

-- 許可權層級

-- 要使用GRANT或REVOKE，您必須擁有GRANT OPTION許可權，並且您必須用於您正在授予或撤銷的許可權。

全域性層級：全域性許可權適用於一個給定伺服器中的所有資料庫，mysql.user

GRANT ALL ON .和 REVOKE ALL ON .只授予和撤銷全域性許可權。

資料庫層級：資料庫許可權適用於一個給定資料庫中的所有目標，mysql.db, mysql.host

GRANT ALL ON db_name.和REVOKE ALL ON db_name.只授予和撤銷資料庫許可權。

表層級：表許可權適用於一個給定表中的所有列，mysql.talbes_priv

GRANT ALL ON db_name.tbl_name和REVOKE ALL ON db_name.tbl_name只授予和撤銷表許可權。

列層級：列許可權適用於一個給定表中的單一列，mysql.columns_priv

當使用REVOKE時，您必須指定與被授權列相同的列。

-- 許可權列表

ALL [PRIVILEGES]    -- 設定除GRANT OPTION之外的所有簡單許可權

ALTER    -- 允許使用ALTER TABLE

ALTER ROUTINE    -- 更改或取消已儲存的子程式

CREATE    -- 允許使用CREATE TABLE

CREATE ROUTINE    -- 建立已儲存的子程式

CREATE TEMPORARY TABLES        -- 允許使用CREATE TEMPORARY TABLE

CREATE USER        -- 允許使用CREATE USER, DROP USER, RENAME USER和REVOKE ALL PRIVILEGES。

CREATE VIEW        -- 允許使用CREATE VIEW

DELETE    -- 允許使用DELETE

DROP    -- 允許使用DROP TABLE

EXECUTE        -- 允許使用者執行已儲存的子程式

FILE    -- 允許使用SELECT...INTO OUTFILE和LOAD DATA INFILE

INDEX     -- 允許使用CREATE INDEX和DROP INDEX

INSERT    -- 允許使用INSERT

LOCK TABLES        -- 允許對您擁有SELECT許可權的表使用LOCK TABLES

PROCESS     -- 允許使用SHOW FULL PROCESSLIST

REFERENCES    -- 未被實施

RELOAD    -- 允許使用FLUSH

REPLICATION CLIENT    -- 允許使用者詢問從屬伺服器或主伺服器的地址

REPLICATION SLAVE    -- 用於複製型從屬伺服器（從主伺服器中讀取二進位制日誌事件）

SELECT    -- 允許使用SELECT

SHOW DATABASES    -- 顯示所有資料庫

SHOW VIEW    -- 允許使用SHOW CREATE VIEW

SHUTDOWN    -- 允許使用mysqladmin shutdown

SUPER    -- 允許使用CHANGE MASTER, KILL, PURGE MASTER LOGS和SET GLOBAL語句，mysqladmin debug命令；允許您連線（一次），即使已達到max_connections。

UPDATE    -- 允許使用UPDATE

USAGE    -- “無許可權”的同義詞

GRANT OPTION    -- 允許授予許可權
/ 表維護 /

-- 分析和儲存表的關鍵字分佈

ANALYZE [LOCAL | NO_WRITE_TO_BINLOG] TABLE 表名 ...

-- 檢查一個或多個表是否有錯誤

CHECK TABLE tbl_name [, tbl_name] ... [option] ...

option = {QUICK | FAST | MEDIUM | EXTENDED | CHANGED}

-- 整理資料檔案的碎片

OPTIMIZE [LOCAL | NO_WRITE_TO_BINLOG] TABLE tbl_name [, tbl_name] ...
/ 雜項 / ------------------

1. 可用反引號（`）為識別符號（庫名、表名、欄位名、索引、別名）包裹，以避免與關鍵字重名！中文也可以作為識別符號！

2. 每個庫目錄存在一個儲存當前資料庫的選項檔案db.opt。

3. 註釋：

單行註釋 # 註釋內容

多行註釋 / 註釋內容 /

單行註釋 -- 註釋內容        (標準SQL註釋風格，要求雙破折號後加一空格符（空格、TAB、換行等）)

4. 模式萬用字元：

_    任意單個字元

%    任意多個字元，甚至包括零字元

單引號需要進行轉義 </span>'

5. CMD命令列內的語句結束符可以為 ";", "\G", "\g"，僅影響顯示結果。其他地方還是用分號結束。delimiter 可修改當前對話的語句結束符。

6. SQL對大小寫不敏感

7. 清除已有語句：\c

5.5.8、常用的SQL

/*==============================================================*/
/* DBMS name:      MySQL 5.0                                    */
/* Created on:     2017/3/5 10:29:05                            */
/*==============================================================*/
drop table if exists Address;
drop table if exists ArticleComment;
drop table if exists ArticleType;
drop table if exists Articles;
drop table if exists DictSub;
drop table if exists DictTop;
drop table if exists OrderPdt;
drop table if exists Orders;
drop table if exists ProductComment;
drop table if exists Products;
drop table if exists Users;
/*/

/ Table: Address                                               /

/*/

create table Address

(

AddressId int not null auto_increment comment '收貨地址編號',

UserId int not null comment '使用者編號',

Province varchar(50) not null comment '省',

City varchar(50) not null comment '市',

County varchar(50) not null comment '縣/區',

Street varchar(300) not null comment '詳細地址',

RevName varchar(30) not null comment '收貨人姓名',

PostCode varchar(20) comment '郵政編碼',

Mobile varchar(50) not null comment '手機',

Phone varchar(50) comment '電話',

IsDefault bool comment '是否為預設地址',

primary key (AddressId)

);
alter table Address comment '收貨地址';
/*/

/ Table: ArticleComment                                        /

/*/

create table ArticleComment

(

ArticleCommentId int not null auto_increment comment '文章評論編號',

ArticleId int not null comment '文章編號',

UserId int not null comment '使用者編號',

ArticleCommentContent varchar(4000) not null comment '文章評論內容',

ArticleCommentDate timestamp default CURRENT_TIMESTAMP comment '文章評論時間',

ArticleCommentState int default 1 comment '狀態',

ArticleRemark int comment '打分',

ArticleCommentReserver1 varchar(4000) comment '備用1',

ArticleCommentReserver2 varchar(4000) comment '備用2',

primary key (ArticleCommentId)

);
alter table ArticleComment comment '文章評論';
/*/

/ Table: ArticleType                                           /

/*/

create table ArticleType

(

ArticleTypeId int not null auto_increment comment '文章欄目編號',

ArticleTypeName varchar(200) comment '文章欄目名稱',

ArticleTypeState int default 1 comment '狀態',

ArticleTypeDesc varchar(4000) comment '文章欄目描述',

ArticleTypePicture varchar(400) comment '文章欄目圖片',

ArticleTypeReserve1 varchar(4000) comment '備用1',

ArticleTypeReserve2 varchar(4000) comment '備用2',

primary key (ArticleTypeId)

);
alter table ArticleType comment '文章欄目';
/*/

/ Table: Articles                                              /

/*/

create table Articles

(

ArticleId int not null auto_increment comment '文章編號',

ArticleTypeId int not null comment '文章欄目編號',

ArticleTitle varchar(400) not null comment '文章標題',

ArticleContent text comment '文章內容',

ArticleDate timestamp default CURRENT_TIMESTAMP comment '文章釋出時間',

ArticleAuthor varchar(200) comment '文章釋出者',

ArticleFileName varchar(100) comment '靜態檔名',

ArticleThumbNail varchar(200) comment '縮圖片',

ArticleAddition varchar(200) comment '附件名稱',

ArticleLevel int comment '顯示的優先順序',

ArticleIsAllowComment integer default 1 comment '是否允許評論',

ArticleState int default 1 comment '狀態',

ArticleHotCount int comment '點選次數',

ArticleReserve1 varchar(4000) comment '備用1',

ArticleReserve2 varchar(4000) comment '備用2',

ArticleReserve3 numeric(8,0) comment '備用3',

primary key (ArticleId)

);
alter table Articles comment '文章';
/*/

/ Table: DictSub                                               /

/*/

create table DictSub

(

SubId int not null auto_increment comment '子項編號',

DictId int not null comment '字典編號',

SubName varchar(200) not null comment '子項名稱',

SubDesc varchar(4000) comment '子項描述',

SubReserve1 varchar(4000) comment '保留備用1',

primary key (SubId)

);
alter table DictSub comment '字典子項';
/*/

/ Table: DictTop                                               /

/*/

create table DictTop

(

DictId int not null auto_increment comment '字典編號',

DictName varchar(100) not null comment '字典名稱',

DictDesc varchar(4000) comment '字典描述',

DictReserve1 varchar(4000) comment '保留備用',

primary key (DictId)

);
alter table DictTop comment '字典';
/*/

/ Table: OrderPdt                                              /

/*/

create table OrderPdt

(

OrderPdtId int not null auto_increment comment '訂單商品編號',

Id int not null comment '編號',

UserId int not null comment '使用者編號',

OrderId int comment '訂單號',

PdtAmount int comment '訂購數量',

PdtPrice decimal comment '單價',

PdtReserve1 varchar(2000) comment '備用1',

PdtReserve2 varchar(4000) comment '備用2',

primary key (OrderPdtId)

);
alter table OrderPdt comment '訂單商品';
/*/

/ Table: Orders                                                /

/*/

create table Orders

(

OrderId int not null auto_increment comment '訂單號',

AddressId int not null comment '收貨地址編號',

OrderState int default 1 comment '訂單狀態',

ExpressNO varchar(50) comment '快遞編號',

ExpressName varchar(50) comment '快遞名稱',

PayMoney decimal comment '應支付',

PayedMoney decimal comment '已支付',

SendInfo varchar(300) comment '發貨人資訊',

BuyDate timestamp default CURRENT_TIMESTAMP comment '下單時間',

PayDate datetime comment '支付時間',

SendDate datetime comment '發貨時間',

ReceivDate datetime comment '收貨時間',

OrderMessage varchar(4000) comment '附言',

UserId integer comment '使用者編號',

OrderReserve1 varchar(4000) comment '備用1',

OrderReserve2 varchar(4000) comment '備用2',

OrderReserve3 decimal comment '備用3',

primary key (OrderId)

);
alter table Orders comment '訂單';
/*/

/ Table: ProductComment                                        /

/*/

create table ProductComment

(

ProductCommentId int not null auto_increment comment '商品評論編號',

ProductId int not null comment '商品編號',

UserId int not null comment '使用者編號',

ProductCommentContent varchar(4000) comment '商品評論內容',

ProductCommentDate timestamp default CURRENT_TIMESTAMP comment '商品評論時間',

ProductCommentState int comment '狀態',

ProductCommentRemark int comment '打分',

ProductCommentReserve1 varchar(4000) comment '備用1',

ProductCommentReserve2 varchar(4000) comment '備用2',

primary key (ProductCommentId)

);
alter table ProductComment comment '商品評論';
/*/

/ Table: Products                                              /

/*/

create table Products

(

Id int not null auto_increment comment '編號',

Name varchar(200) not null comment '名稱',

SubIdColor int not null comment '所屬顏色',

SubIdBrand int not null comment '所屬品牌',

SubIdInlay int not null comment '所屬鑲嵌',

SubIdMoral int not null comment '所屬寓意',

SubIdMaterial int not null comment '所屬種水',

SubIdTopLevel int not null comment '一級分類編號',

MarketPrice decimal comment '市場參考價',

MyPrice decimal not null comment '玉源直銷價',

Discount decimal default 1 comment '折扣',

Picture varchar(200) comment '圖片',

Amount int comment '庫存量',

Description text comment '詳細描述',

State int default 1 comment '狀態',

AddDate timestamp default CURRENT_TIMESTAMP comment '上貨日期',

Hang int comment '掛件',

RawStone int comment '賭石',

Size varchar(200) comment '尺寸',

ExpressageName varchar(100) comment '快遞名稱',

Expressage decimal comment '快遞費',

AllowComment int default 1 comment '是否允許評論',

Reserve1 varchar(4000) comment '保留備用1',

Reserve2 varchar(4000) comment '保留備用2',

Reserve3 decimal(0) comment '保留備用3',

primary key (Id)

);
alter table Products comment '商品';
/*/

/ Table: Users                                                 /

/*/

create table Users

(

UserId int not null auto_increment comment '使用者編號',

UserName varchar(200) not null comment '使用者名稱',

Password varchar(512) not null comment '密碼',

Email varchar(100) not null comment '郵箱',

Sex varchar(10) comment '性別',

State int default 1 comment '狀態',

RightCode int comment '許可權狀態',

RegDate timestamp default CURRENT_TIMESTAMP comment '註冊時間',

RegIP varchar(200) comment '註冊IP',

LastLoginDate datetime comment '最近登入時間',

UserReserve1 varchar(4000) comment '保留備用1',

UserReserve2 varchar(4000) comment '保留備用2',

UserReserve3 varchar(4000) comment '保留備用3',

primary key (UserId)

);
alter table Users comment '使用者';
alter table Address add constraint FK_AddressBelongUser foreign key (UserId)

references Users (UserId) on delete restrict on update restrict;
alter table ArticleComment add constraint FK_ArticleCommentForArticle foreign key (ArticleId)

references Articles (ArticleId) on delete restrict on update restrict;
alter table ArticleComment add constraint FK_ArticleCommentForUser foreign key (UserId)

references Users (UserId) on delete restrict on update restrict;
alter table Articles add constraint FK_ArticleBelongType foreign key (ArticleTypeId)

references ArticleType (ArticleTypeId) on delete restrict on update restrict;
alter table DictSub add constraint FK_BelongDict foreign key (DictId)

references DictTop (DictId) on delete cascade on update cascade;
alter table OrderPdt add constraint FK_BelongOrder foreign key (OrderId)

references Orders (OrderId) on delete cascade on update cascade;
alter table OrderPdt add constraint FK_CartForUser foreign key (UserId)

references Users (UserId) on delete restrict on update restrict;
alter table OrderPdt add constraint FK_OrderDepProduct foreign key (Id)

references Products (Id) on delete restrict on update restrict;
alter table Orders add constraint FK_OrderBelongAddress foreign key (AddressId)

references Address (AddressId) on delete restrict on update restrict;
alter table ProductComment add constraint FK_ProductCommentBelongUsers foreign key (UserId)

references Users (UserId) on delete restrict on update restrict;
alter table ProductComment add constraint FK_ProductCommentForProduct foreign key (ProductId)

references Products (Id) on delete restrict on update restrict;
alter table Products add constraint FK_BelongBrand foreign key (SubIdMaterial)

references DictSub (SubId) on delete restrict on update restrict;
alter table Products add constraint FK_BelongColor foreign key (SubIdBrand)

references DictSub (SubId) on delete restrict on update restrict;
alter table Products add constraint FK_BelongInlay foreign key (SubIdInlay)

references DictSub (SubId) on delete restrict on update restrict;
alter table Products add constraint FK_BelongMaterial foreign key (SubIdColor)

references DictSub (SubId) on delete restrict on update restrict;
alter table Products add constraint FK_BelongMoral foreign key (SubIdTopLevel)

references DictSub (SubId) on delete restrict on update restrict;
alter table Products add constraint FK_BelongTopLevel foreign key (SubIdMoral)

references DictSub (SubId) on delete restrict on update restrict;

5.6、MySQL與SQLServer的區別

ER圖、分頁、差異、Java連線MySQL

SELECT * FROM table LIMIT [offset,] rows | rows OFFSET offset

LIMIT 子句可以被用於強制 SELECT 語句返回指定的記錄數。LIMIT 接受一個或兩個數字引數。引數必須是一個整數常量。如果給定兩個引數，第一個引數指定第一個返回記錄行的偏移量，第二個引數指定返回記錄行的最大數目。初始記錄行的偏移量是 0(而不是 1)：為了與 PostgreSQL 相容，MySQL 也支援句法： LIMIT # OFFSET #。

5.6.1、區別一

1 mysql支援enum,和set型別，sql server不支援
2 mysql不支援nchar,nvarchar,ntext型別
3 mysql的遞增語句是AUTO_INCREMENT，而mssql是identity(1,1)
4 msms預設到處表建立語句的預設值表示是((0)),而在mysql裡面是不允許帶兩括號的
5 mysql需要為表指定儲存型別
6 mssql識別符是[],[type]表示他區別於關鍵字，但是mysql卻是 `，也就是按鍵1左邊的那個符號
7 mssql支援getdate()方法獲取當前時間日期，但是mysql裡面可以分日期型別和時間型別，獲取當前日期是cur_date()，當前完整時間是 now()函式
8 mssql不支援replace into 語句，但是在最新的sql20008裡面，也支援merge語法
9 mysql支援insert into table1 set t1 = ‘’, t2 = ‘’ ,但是mssql不支援這樣寫
10 mysql支援insert into tabl1 values (1,1), (1,1), (1,1), (1,1), (1,1), (1,1), (1,1)
11 mssql不支援limit語句，是非常遺憾的，只能用top 取代limt 0,N，row_number() over()函式取代limit N,M
12 mysql在建立表時要為每個表指定一個儲存引擎型別，而mssql只支援一種儲存引擎
13 mysql不支援預設值為當前時間的datetime型別（mssql很容易做到），在mysql裡面是用timestamp型別
14 mssql裡面檢查是否有這個表再刪除，需要這樣：
if   exists   (select   *   from   dbo.sysobjects   where   id   =   object_id(N'uc_newpm')   and   OBJECTPROPERTY(id,   N'IsUserTable')   =   1)
但是在mysql裡面只需要 DROP TABLE IF EXISTS cdb_forums;
15 mysql支援無符號型的整數，那麼比不支援無符號型的mssql就能多出一倍的最大數儲存
16 mysql不支援在mssql裡面使用非常方便的varchar(max)型別，這個型別在mssql裡面既可做一般資料儲存，也可以做blob資料儲存
17 mysql建立非聚集索引只需要在建立表的時候指定為key就行，比如：KEY displayorder (fid,displayorder) 在mssql裡面必須要：create unique nonclustered index index_uc_protectedmembers_username_appid on dbo.uc_protectedmembers
(username asc,appid asc)
18 mysql text欄位型別不允許有預設值
19mysql的一個表的總共欄位長度不超過65XXX。
20一個很表面的區別就是mysql的安裝特別簡單，而且檔案大小才110M（非安裝版），相比微軟這個龐然大物，安裝進度來說簡直就是.....
21mysql的管理工具有幾個比較好的，mysql_front,和官方那個套件，不過都沒有SSMS的使用方便，這是mysql很大的一個缺點。
22mysql的儲存過程只是出現在最新的版本中，穩定性和效能可能不如mssql。
23 同樣的負載壓力，mysql要消耗更少的CPU和記憶體，mssql的確是很耗資源。
24php連線mysql和mssql的方式都差不多，只需要將函式的mysql替換成mssql即可。
25mysql支援date,time,year型別，mssql到2008才支援date和time。

5.6.2、區別二

一資料定義
1 資料庫操作基本命令
Mysql:
create database name; 建立資料庫 
use databasename; 選擇資料庫 
drop database name 直接刪除資料庫，不提醒 –
2 CREATE TABLE --建立一個數據庫表
2.1    PRIMARY KEY 約束（主鍵）區別解析：
2.1.1 建立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：
CREATE TABLE Persons
(
Id_P int NOT NULL PRIMARY KEY,     //宣告主健 緊跟列後
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Address varchar(255),
City varchar(255)
)
但是如果表存在，之後給表加主健時：
Mysql 和SqlServer
ALTER TABLE Persons ADD PRIMARY KEY (Id_P)
2.1.2撤銷 PRIMARY KEY 約束
MySQL:
ALTER TABLE Persons DROP PRIMARY KEY
SQL Server
ALTER TABLE Persons DROP CONSTRAINT pk_PersonID
2.1.3 建立外健約束
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

CREATE TABLE Orders

(

O_Id  int  NOT NULL  PRIMARY KEY,

OrderNo  int NOT NULL,

Id_P  int  FOREIGN KEY REFERENCES Persons(Id_P)    //順序不同

)

如果在 "Orders" 表已存在的情況下為 "Id_P" 列建立 FOREIGN KEY 約束，請使用下面的 SQL：

MySQL / SQL Server

ALTER  TABLE  Orders ADD  FOREIGN KEY  (Id_P) REFERENCES  Persons(Id_P)

2.1.4 撤銷外健約束

MySQL:

ALTER TABLE Orders DROP  FOREIGN KEY f k_PerOrders

SQL Server

ALTER TABLE Orders DROP CONSTRAINT  fk_PerOrders

2.2     UNIQUE 約束（唯一的，獨一無二的）區別解析

UNIQUE 約束唯一標識資料庫表中的每條記錄。

UNIQUE 和 PRIMARY KEY 約束均為列或列集合提供了唯一性的保證。

PRIMARY KEY 擁有自動定義的 UNIQUE 約束。

請注意，每個表可以有多個 UNIQUE 約束，但是每個表只能有一個 PRIMARY KEY 約束。

2.2.1 建立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

CREATE TABLE Persons

(

Id_P int NOT NULL UNIQUE,        //緊跟列後

LastName varchar(255) NOT NULL,

FirstName varchar(255),

Address varchar(255),

City varchar(255)

)

2.2.2 撤銷 UNIQUE 約束

MySQL:

ALTER TABLE Persons DROP INDEX  uc_PersonID

SQL Server

ALTER TABLE Persons DROP CONSTRAINT uc_PersonID

2.3    CHECK 約束

CHECK 約束用於限制列中的值的範圍。

如果對單個列定義 CHECK 約束，那麼該列只允許特定的值。

如果對一個表定義 CHECK 約束，那麼此約束會在特定的列中對值進行限制。

2.3.1 建立 CHECK約束

下面的 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

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:

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') //多個條件

)

如果在表已存在的情況下為 "Id_P" 列建立 CHECK 約束，請使用下面的 SQL：

MySQL / SQL Server:

ALTER TABLE Persons ADD CHECK (Id_P>0)

2.3.2 撤銷 CHECK約束

Sqlserver:

ALTER  TABLE  Persons  DROP CONSTRAINT chk_Person

Mysql我沒有找到怎麼刪除。

2.4    DEFAULT 約束（系統預設值）

DEFAULT 約束用於向列中插入預設值。

如果沒有規定其他的值，那麼會將預設值新增到所有的新紀錄。

2.4.1 建立DEFAULT約束

下面的 SQL 在 "Persons" 表建立時為 "City" 列建立 DEFAULT 約束：

My SQL / SQL Server:

CREATE TABLE Persons

(

Id_P int NOT NULL,

LastName varchar(255) NOT NULL,

FirstName varchar(255),

Address varchar(255),

City varchar(255) DEFAULT 'Sandnes'     //緊跟列後，預設值字串Sandnes

)
通過使用類似 GETDATE() 這樣的函式，DEFAULT 約束也可以用於插入系統值：

CREATE TABLE Orders

(

Id_O int NOT NULL,

OrderNo int NOT NULL,

Id_P int,

OrderDate date DEFAULT GETDATE()   //緊跟列後，函式

)
如果在表已存在的情況下為 "City" 列建立 DEFAULT 約束，請使用下面的 SQL：
MySQL:

ALTER  TABLE  Persons  ALTER  City  SET  DEFAULT  'SANDNES'
SQL Server:

ALTER  TABLE  Persons  ALTER  COLUMN  City  SET  DEFAULT  'SANDNES'

2.4 .2 撤消DEFAULT約束

MySQL:

ALTER  TABLE  Persons  ALTER  City  DROP  DEFAULT
SQL Server:

ALTER  TABLE  Persons  ALTER  COLUMN  City  DROP  DEFAULT

2.5    索引區別

CREATE INDEX 語句

CREATE INDEX 語句用於在表中建立索引。

在不讀取整個表的情況下，索引使資料庫應用程式可以更快地查詢資料。

在表上建立一個簡單的索引。允許使用重複的值：

CREATE INDEX index_name ON table_name (column_name) //"column_name" 規定需要索引的列。

在表上建立一個唯一的索引。唯一的索引意味著兩個行不能擁有相同的索引值。

CREATE UNIQUE INDEX index_name ON table_name (column_name)

Mysql和SqlServer的建立索引都是一致的，但是在刪除索引方面卻有區別:

SqlServer: DROP INDEX table_name.index_name

Mysql: ALTER TABLE table_name DROP INDEX index_name

2.6    主鍵自動增加的區別

mySql的主鍵自動增加是用auto_increment欄位，sqlServer的自動增加則是identity欄位.

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
用於 SQL Server 的語法

下列 SQL 語句把 "Persons" 表中的 "P_Id" 列定義為 auto-increment 主鍵：

CREATE TABLE Persons

(

P_Id int PRIMARY KEY IDENTITY,或則是寫成P_id int primary key identity (1,1),

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)

2.7    MySQL支援enum,和set型別，SQL Server不支援

2.7.1    列舉enum

ENUM是一個字串物件，其值來自表建立時在列規定中顯式列舉的一列值.

列舉最多可以有65,535個元素。

列舉的簡單用法舉例:

mysql> create table meijut (f1 enum('1','2','3','4','5','6'));

mysql> desc meijut;

+-------+-------------------------------+------+-----+---------+-------+

| Field | Type                          | Null | Key | Default | Extra |

+-------+-------------------------------+------+-----+---------+-------+

| f1    | enum('1','2','3','4','5','6') | YES  |     | NULL    |       |

+-------+-------------------------------+------+-----+---------+-------+

mysql> insert into meijut values(8);

mysql> select  from meijut

-> ;

+------+

| f1   |

+------+

|      |

+------+

這個情況說明如果你將一個非法值插入ENUM(也就是說，允許的值列之外的字串)，將插入空字串以作為特殊錯誤值。該字串與“普通”空字串不同，該字串有數值值0。

mysql> insert into meijut values('3');

mysql> insert into meijut values(3);

mysql> insert into meijut values('4');

mysql> insert into meijut values('5');

mysql> select  from meijut;

+------+

| f1   |

+------+

|      |

| 3    |

| 3    |

| 4    |

| 5    |

+------+  

改表
mysql> alter table meiju modify f1 enum("a","b","c","d","e","f");

可以自動將記錄當序號匹配成新的欄位值

mysql> select  from meijut;

+------+

| f1   |

+------+

|      |

| c    |

| c    |

| d    |

| e    |

+------+  

2.7.2    集合set

mysql> create table jihe(f1 set('f','m'));

mysql> insert into jihe values('f');

可以按照序號輸入 注意序號為 1 2 4 8 16 32 ....

mysql> insert into jihe values('3');

mysql> select  from jihe;

+------+

| f1   |

+------+

| f    |

| f,m  |

+------+ 

其他字母不能插入

mysql> insert into jihe values("q");

ERROR 1265 (01000): Data truncated for column 'f1' at row 1

插入空

mysql> insert into jihe values("0");

Query OK, 1 row affected (0.11 sec)

超出序號之和不能插入

mysql> insert into jihe values("4");

ERROR 1265 (01000): Data truncated for column 'f1' at row 1

集合 和 列舉的區別

1 集合可以有64個值 列舉有65535個

2 集合的序號是 1 2 4 8 16 列舉是 1 2 3 4 5 6

3 集合一個欄位值可以有好幾個值

+-------+

| f1    |

+-------+

| f,m   |

+-------+
2.8    MySQL不支援nchar,nvarchar,ntext型別

3    DROP TABLE –刪除一個數據庫表

Mysql判斷一個數據庫表是否存在並刪除的語句是：

drop table if exists jihe;

SqlServer判斷一個數據庫表是否存在並刪除的語句是：

if exists (select * from sysobjects where name='Sheet1$' and xtype='U')

drop table Sheet1$

其中jihe和Sheet1$指的均是資料庫表名

4    顯示庫表

Mysql:

Show tables;//顯示一個庫中的所有表

Desc table;/顯示一個表的表結構

mysql> desc meijut;

+-------+-------------------------------+------+-----+---------+-------+

| Field | Type                          | Null | Key | Default | Extra |

+-------+-------------------------------+------+-----+---------+-------+

| f1    | enum('a','b','c','d','e','f') | YES  |     | NULL    |       |

| f2    | int(11)                       | YES  |     | 0       |       |

| f3    | text                          | YES  |     | NULL    |       |

+-------+-------------------------------+------+-----+---------+-------+ 

Show create table tablename;//顯示一個表的詳細建立資訊

mysql> show create table meijut;

+--------+-------------------------------------------

-----------------------------------------------------

---+

| Table  | Create Table
|

+--------+-------------------------------------------

-----------------------------------------------------

---+

| meijut | CREATE TABLE meijut (

f1 enum('a','b','c','d','e','f') default NULL,

f2 int(11) default '0',

f3 text

) ENGINE=MyISAM DEFAULT CHARSET=utf8 |

5    alter 修改庫表
重命名錶: -

mysql > alter table t1 rename t2;

新增一列

mysql> alter table meijut add column f2 int default 0 ;

修改一列

mysql> alter table meijut modify f2 text;
二 資料操作

2.1 limit和top

SQL SERVER : select   top   8      from   table1

MYSQL: select      from   table1   limit   5或則是 limit 0,5;

注意，在MySQL中的limit不能放在子查詢內，limit不同與top,它可以規定範圍 limit a,b——範圍a-b

2.2  ISNULL()函式

SqlServer:

select  from test where isnull(no,0)=0;

MySQL

MySQL 可以使用 ISNULL() 函式。不過它的工作方式與微軟的 ISNULL() 函式有點不同。

在 MySQL 中，我們可以使用 IFNULL() 函式，就像這樣：

mysql> select  from test where ifnull(no,0)=0;

+----+------+

| id | no   |

+----+------+

|  3 | NULL |

+----+------+

1 row in set (0.03 sec)

2.3 select查詢

SELECT  FROM tablename

2.4 insert 插入

INSERT INTO table(col1,col2) values(value1,value2);

MySQL支援insert into table1 set t1 = ‘’, t2=‘’,但是MSSQL不支援這樣寫

2.6update 修改

Update  tablename set  col=”value”;

2.7 delete 刪除

Delete from tablename;

三 語法定義

3.1 註釋符區別

SqlServer的註釋符為--和//

MySql的註釋符為--和//和#

3.2 識別符的區別

MS SQL識別符是[],[type]表示他區別於關鍵字，但是MySQL卻是 `，也就是按鍵1左邊的那個符號

3.3儲存過程的區別（未經驗證，從網上找的）

(1)    mysql的儲存過程中變數的定義去掉@;

(2)    SQLServer儲存過程的AS在MySql中需要用begin .....end替換

(3)    Mysql的Execute對應SqlServer的exec;

(注意：必須想下面這樣呼叫)

Set @cnt=’select  from 表名’;

Prepare str from @cnt;

Execute str;

(4)    MySql儲存過程呼叫其他儲存過程用call

Call 函式名（即SQLServer的儲存過程名）（’引數1’,’引數2’,……）

(5)    select @a=count() from VW_Action 在mySql中修改為：select count() from VW_Action into @a;

(6)    MySQL檢視的FROM子句不允許存在子查詢，因此對於SQL Server中FROM子句帶有子查詢的檢視，需要手工進行遷移。可通過消除FROM子句中的子查詢，或將FROM子句中的子查詢重構為一個新的檢視來進行遷移。

(7)    )MySql儲存過程中沒有return函式，在MySql中可以用迴圈和out引數代替

If EXISTS(SELECT  FROM T_Chance WHERE FCustID=CostomerID)  return 0

改寫為：

（在引數中定義一個out變數：out temp varchar(100);）

BEGIN

Loop1:loop

SELECT count() FROM T_Chance WHERE FCustID=CostomerID int @cnt

If @cnt>0 then

begin

set temp=0;

leave loop1;

end;

end if

end loop loop1;

(8)    mysql的uuid()對應sql的GUID();

(9)    MySql的out對應SQLServer的output,且mysql 的out要放在變數的前面，SQLServer的output放在變數後面：

MySql out,in,inout的區別——

MySQL 儲存過程 “in” 引數：跟 C 語言的函式引數的值傳遞類似， MySQL 儲存過程內部可能會修改此引數，但對 in 型別引數的修改，對呼叫者（caller）來說是不可見的（not visible）。

MySQL 儲存過程 “out” 引數：從儲存過程內部傳值給呼叫者。在儲存過程內部，該引數初始值為 null，無論呼叫者是否給儲存過程引數設定值。

MySQL 儲存過程 inout 引數跟 out 類似，都可以從儲存過程內部傳值給呼叫者。不同的是：呼叫者還可以通過 inout 引數傳遞值給儲存過程。

3.4字串連線

SQLServer: Temp=’select  from ’+’tablename’+…+…

MySql:Temp=concat(’select  from’, ’tablecname’,…,…)

四 函式和資料型別的區別

4.1 Date 函式

MySQL Date 函式

NOW() 返回當前的日期和時間

CURDATE() 返回當前的日期

CURTIME() 返回當前的時間

DATE() 提取日期或日期/時間表達式的日期部分

EXTRACT() 返回日期/時間按的單獨部分

DATE_ADD() 給日期新增指定的時間間隔

DATE_SUB() 從日期減去指定的時間間隔

DATEDIFF() 返回兩個日期之間的天數

DATE_FORMAT() 用不同的格式顯示日期/時間
SQL Server Date 函式

GETDATE() 返回當前日期和時間

DATEPART() 返回日期/時間的單獨部分

DATEADD() 在日期中新增或減去指定的時間間隔

DATEDIFF() 返回兩個日期之間的時間

CONVERT() 用不同的格式顯示日期/時間
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 - 格式: 唯一的數字

五效能比較

（1）一個很表面的區別就是MySQL的安裝特別簡單，而且檔案大小才110M(非安裝版)，相比微軟這個龐然大物，安裝進度來說簡直就是.....

（2）MySQL的管理工具有幾個比較好的，MySQL_front,和官方那個套件，不過都沒有SSMS的使用方便，這是MySQL很大的一個缺點。

（3）MySQL的儲存過程只是出現在最新的版本中，穩定性和效能可能不如MS SQL。

（4）同
樣的負載壓力，MySQL要消耗更少的CPU和記憶體，MS SQL的確是很耗資源。
1、把主鍵定義為自動增長識別符號型別

MySql

在mysql中，如果把表的主鍵設為auto_increment型別，資料庫就會自動為主鍵賦值。例如：

create table customers(id int auto_increment primary key not null, name varchar(15));
最近在做mssql轉換成mysql的工作，總結了點經驗，跟大家分享一下。

同時這些也會在不斷更新。也希望大家補充。
1 mysql支援enum,和set型別，sql server不支援

2 mysql不支援nchar,nvarchar,ntext型別

3 mysql的遞增語句是AUTO_INCREMENT，而mssql是identity(1,1)

4 msms預設到處表建立語句的預設值表示是((0)),而在mysql裡面是不允許帶兩括號的

5 mysql需要為表指定儲存型別

6 mssql識別符是[],[type]表示他區別於關鍵字，但是mysql卻是 `，也就是按鍵1左邊的那個符號

7 mssql支援getdate()方法獲取當前時間日期，但是mysql裡面可以分日期型別和時間型別，獲取當前日期是cur_date()，當前完整時間是 now()函式

8 mssql不支援replace into 語句，但是在最新的sql20008裡面，也支援merge語法

9 mysql支援insert into table1 set t1 = ‘’, t2 = ‘’ ,但是mssql不支援這樣寫

10 mysql支援insert into tabl1 values (1,1), (1,1), (1,1), (1,1), (1,1), (1,1), (1,1)

11 mssql不支援limit語句，是非常遺憾的，只能用top 取代limt 0,N，row_number() over()函式取代limit N,M

12 mysql在建立表時要為每個表指定一個儲存引擎型別，而mssql只支援一種儲存引擎

13 mysql不支援預設值為當前時間的datetime型別（mssql很容易做到），在mysql裡面是用timestamp型別

14 mssql裡面檢查是否有這個表再刪除，需要這樣：

if   exists   (select   *   from   dbo.sysobjects   where   id   =   object_id(N'uc_newpm')   and   OBJECTPROPERTY(id,   N'IsUserTable')   =   1)

但是在mysql裡面只需要 DROP TABLE IF EXISTS cdb_forums;

15 mysql支援無符號型的整數，那麼比不支援無符號型的mssql就能多出一倍的最大數儲存

16 mysql不支援在mssql裡面使用非常方便的varchar(max)型別，這個型別在mssql裡面既可做一般資料儲存，也可以做blob資料儲存

17 mysql建立非聚集索引只需要在建立表的時候指定為key就行，比如：KEY displayorder (fid,displayorder) 在mssql裡面必須要：create unique nonclustered index index_uc_protectedmembers_username_appid on dbo.uc_protectedmembers

(username asc,appid asc)
18 mysql text欄位型別不允許有預設值

19mysql的一個表的總共欄位長度不超過65XXX。

20一個很表面的區別就是mysql的安裝特別簡單，而且檔案大小才110M（非安裝版），相比微軟這個龐然大物，安裝進度來說簡直就是.....

21mysql的管理工具有幾個比較好的，mysql_front,和官方那個套件，不過都沒有SSMS的使用方便，這是mysql很大的一個缺點。

22mysql的儲存過程只是出現在最新的版本中，穩定性和效能可能不如mssql。

23 同樣的負載壓力，mysql要消耗更少的CPU和記憶體，mssql的確是很耗資源。

24php連線mysql和mssql的方式都差不多，只需要將函式的mysql替換成mssql即可。

25mysql支援date,time,year型別，mssql到2008才支援date和time。
MySQL 的數值資料型別可以大致劃分為兩個類別，一個是整數，另一個是浮點數或小數。許多不同的子型別對這些類別中的每一個都是可用的，每個子型別支援不同大小的資料，並且 MySQL 允許我們指定數值欄位中的值是否有正負之分或者用零填補。

　　表列出了各種數值型別以及它們的允許範圍和佔用的記憶體空間。

型別 大小 範圍（有符號） 範圍（無符號） 用途

TINYINT 1 位元組 (-128，127) (0，255) 小整數值

SMALLINT 2 位元組 (-32 768，32 767) (0，65 535) 大整數值

MEDIUMINT 3 位元組 (-8 388 608，8 388 607) (0，16 777 215) 大整數值

INT或INTEGER 4 位元組 (-2 147 483 648，2 147 483 647) (0，4 294 967 295) 大整數值

BIGINT 8 位元組 (-9 233 372 036 854 775 808，9 223 372 036 854 775 807) (0，18 446 744 073 709 551 615) 極大整數值

FLOAT 4 位元組 (-3.402 823 466 E+38，1.175 494 351 E-38)，0，(1.175 494 351 E-38，3.402 823 466 351 E+38) 0，(1.175 494 351 E-38，3.402 823 466 E+38) 單精度

浮點數值

DOUBLE 8 位元組 (1.797 693 134 862 315 7 E+308，2.225 073 858 507 201 4 E-308)，0，(2.225 073 858 507 201 4 E-308，1.797 693 134 862 315 7 E+308) 0，(2.225 073 858 507 201 4 E-308，1.797 693 134 862 315 7 E+308) 雙精度

浮點數值

DECIMAL 對DECIMAL(M,D) ，如果M>D，為M+2否則為D+2 依賴於M和D的值 依賴於M和D的值 小數值

INT 型別

　　在 MySQL 中支援的 5 個主要整數型別是 TINYINT，SMALLINT，MEDIUMINT，INT 和 BIGINT。這些型別在很大程度上是相同的，只有它們儲存的值的大小是不相同的。

　　MySQL 以一個可選的顯示寬度指示器的形式對 SQL 標準進行擴充套件，這樣當從資料庫檢索一個值時，可以把這個值加長到指定的長度。例如，指定一個欄位的型別為 INT(6)，就可以保證所包含數字少於 6 個的值從資料庫中檢索出來時能夠自動地用空格填充。需要注意的是，使用一個寬度指示器不會影響欄位的大小和它可以儲存的值的範圍。

　　萬一我們需要對一個欄位儲存一個超出許可範圍的數字，MySQL 會根據允許範圍最接近它的一端截短後再進行儲存。還有一個比較特別的地方是，MySQL 會在不合規定的值插入表前自動修改為 0。

　　UNSIGNED 修飾符規定欄位只儲存正值。因為不需要儲存數字的正、負符號，可以在儲時節約一個“位”的空間。從而增大這個欄位可以儲存的值的範圍。

　　ZEROFILL 修飾符規定 0（不是空格）可以用來真補輸出的值。使用這個修飾符可以阻止 MySQL 資料庫儲存負值。

FLOAT、DOUBLE 和 DECIMAL 型別

　　MySQL 支援的三個浮點型別是 FLOAT、DOUBLE 和 DECIMAL 型別。FLOAT 數值型別用於表示單精度浮點數值，而 DOUBLE 數值型別用於表示雙精度浮點數值。

　　與整數一樣，這些型別也帶有附加引數：一個顯示寬度指示器和一個小數點指示器。比如語句 FLOAT(7,3) 規定顯示的值不會超過 7 位數字，小數點後面帶有 3 位數字。

　　對於小數點後面的位數超過允許範圍的值，MySQL 會自動將它四捨五入為最接近它的值，再插入它。

　　DECIMAL 資料型別用於精度要求非常高的計算中，這種型別允許指定數值的精度和計數方法作為選擇引數。精度在這裡指為這個值儲存的有效數字的總個數，而計數方法表示小數點後數字的位數。比如語句 DECIMAL(7,3) 規定了儲存的值不會超過 7 位數字，並且小數點後不超過 3 位。

　　忽略 DECIMAL 資料型別的精度和計數方法修飾符將會使 MySQL 資料庫把所有標識為這個資料型別的欄位精度設定為 10，計算方法設定為 0。

　　UNSIGNED 和 ZEROFILL 修飾符也可以被 FLOAT、DOUBLE 和 DECIMAL 資料型別使用。並且效果與 INT 資料型別相同。

字串型別

　　MySQL 提供了 8 個基本的字串型別，可以儲存的範圍從簡單的一個字元到巨大的文字塊或二進位制字串資料。

型別 大小 用途

CHAR 0-255位元組 定長字串

VARCHAR 0-255位元組 變長字串

TINYBLOB 0-255位元組 不超過 255 個字元的二進位制字串

TINYTEXT 0-255位元組 短文字字串

BLOB 0-65 535位元組 二進位制形式的長文字資料

TEXT 0-65 535位元組 長文字資料

MEDIUMBLOB 0-16 777 215位元組 二進位制形式的中等長度文字資料

MEDIUMTEXT 0-16 777 215位元組 中等長度文字資料

LOGNGBLOB 0-4 294 967 295位元組 二進位制形式的極大文字資料

LONGTEXT 0-4 294 967 295位元組 極大文字資料

CHAR 和 VARCHAR 型別

　　CHAR 型別用於定長字串，並且必須在圓括號內用一個大小修飾符來定義。這個大小修飾符的範圍從 0-255。比指定長度大的值將被截短，而比指定長度小的值將會用空格作填補。

　　CHAR 型別可以使用 BINARY 修飾符。當用於比較運算時，這個修飾符使 CHAR 以二進位制方式參於運算，而不是以傳統的區分大小寫的方式。

　　CHAR 型別的一個變體是 VARCHAR 型別。它是一種可變長度的字串型別，並且也必須帶有一個範圍在 0-255 之間的指示器。CHAR 和 VARCHGAR 不同之處在於 MuSQL 資料庫處理這個指示器的方式：CHAR 把這個大小視為值的大小，不長度不足的情況下就用空格補足。而 VARCHAR 型別把它視為最大值並且只使用儲存字串實際需要的長度（增加一個額外位元組來儲存字串本身的長度）來儲存值。所以短於指示器長度的 VARCHAR 型別不會被空格填補，但長於指示器的值仍然會被截短。

　　因為 VARCHAR 型別可以根據實際內容動態改變儲存值的長度，所以在不能確定欄位需要多少字元時使用 VARCHAR 型別可以大大地節約磁碟空間、提高儲存效率。

　　VARCHAR 型別在使用 BINARY 修飾符時與 CHAR 型別完全相同。

TEXT 和 BLOB 型別

　　對於欄位長度要求超過 255 個的情況下，MySQL 提供了 TEXT 和 BLOB 兩種型別。根據儲存資料的大小，它們都有不同的子型別。這些大型的資料用於儲存文字塊或影象、聲音檔案等二進位制資料型別。

　　TEXT 和 BLOB 型別在分類和比較上存在區別。BLOB 型別區分大小寫，而 TEXT 不區分大小寫。大小修飾符不用於各種 BLOB 和 TEXT 子型別。比指定型別支援的最大範圍大的值將被自動截短。

日期和時間型別

　　在處理日期和時間型別的值時，MySQL 帶有 5 個不同的資料型別可供選擇。它們可以被分成簡單的日期、時間型別，和混合日期、時間型別。根據要求的精度，子型別在每個分型別中都可以使用，並且 MySQL 帶有內建功能可以把多樣化的輸入格式變為一個標準格式。

型別 大小

(位元組) 範圍 格式 用途

DATE 3 1000-01-01/9999-12-31 YYYY-MM-DD 日期值

TIME 3 '-838:59:59'/'838:59:59' HH:MM:SS 時間值或持續時間

YEAR 1 1901/2155 YYYY 年份值

DATETIME 8 1000-01-01 00:00:00/9999-12-31 23:59:59 YYYY-MM-DD HH:MM:SS 混合日期和時間值

TIMESTAMP 8 1970-01-01 00:00:00/2037 年某時 YYYYMMDD HHMMSS 混合日期和時間值，時間戳

DATE、TIME 和 TEAR 型別

　　MySQL 用 DATE 和 TEAR 型別儲存簡單的日期值，使用 TIME 型別儲存時間值。這些型別可以描述為字串或不帶分隔符的整數序列。如果描述為字串，DATE 型別的值應該使用連字號作為分隔符分開，而 TIME 型別的值應該使用冒號作為分隔符分開。

　　需要注意的是，沒有冒號分隔符的 TIME 型別值，將會被 MySQL 理解為持續的時間，而不是時間戳。

　　MySQL 還對日期的年份中的兩個數字的值，或是 SQL 語句中為 TEAR 型別輸入的兩個數字進行最大限度的通譯。因為所有 TEAR 型別的值必須用 4 個數字儲存。MySQL 試圖將 2 個數字的年份轉換為 4 個數字的值。把在 00-69 範圍內的值轉換到 2000-2069 範圍內。把 70-99 範圍內的值轉換到 1970-1979 之內。如果 MySQL 自動轉換後的值並不符合我們的需要，請輸入 4 個數字表示的年份。

DATEYIME 和 TIMESTAMP 型別

　　 除了日期和時間資料型別，MySQL 還支援 DATEYIME 和 TIMESTAMP 這兩種混合型別。它們可以把日期和時間作為單個的值進行儲存。這兩種型別通常用於自動儲存包含當前日期和時間的時間戳，並可在需要執行大量資料庫事務和需要建立一個除錯和審查用途的審計跟蹤的應用程式中發揮良好作用。

　　如果我們對 TIMESTAMP 型別的欄位沒有明確賦值，或是被賦與了 null 值。MySQL 會自動使用系統當前的日期和時間來填充它。

複合型別

　　MySQL 還支援兩種複合資料型別 ENUM 和 SET，它們擴充套件了 SQL 規範。雖然這些型別在技術上是字串型別，但是可以被視為不同的資料型別。一個 ENUM 型別只允許從一個集合中取得一個值；而 SET 型別允許從一個集合中取得任意多個值。

ENUM 型別

　　ENUM 型別因為只允許在集合中取得一個值，有點類似於單選項。在處理相互排拆的資料時容易讓人理解，比如人類的性別。ENUM 型別欄位可以從集合中取得一個值或使用 null 值，除此之外的輸入將會使 MySQL 在這個欄位中插入一個空字串。另外如果插入值的大小寫與集合中值的大小寫不匹配，MySQL 會自動使用插入值的大小寫轉換成與集合中大小寫一致的值。

　　 ENUM 型別在系統內部可以儲存為數字，並且從 1 開始用數字做索引。一個 ENUM 型別最多可以包含 65536 個元素，其中一個元素被 MySQL 保留，用來儲存錯誤資訊，這個錯誤值用索引 0 或者一個空字串表示。

　　MySQL 認為 ENUM 型別集合中出現的值是合法輸入，除此之外其它任何輸入都將失敗。這說明通過搜尋包含空字串或對應數字索引為 0 的行就可以很容易地找到錯誤記錄的位置。

SET 型別

　　SET 型別與 ENUM 型別相似但不相同。SET 型別可以從預定義的集合中取得任意數量的值。並且與 ENUM 型別相同的是任何試圖在 SET 型別欄位中插入非預定義的值都會使 MySQL 插入一個空字串。如果插入一個即有合法的元素又有非法的元素的記錄，MySQL 將會保留合法的元素，除去非法的元素。

　　一個 SET 型別最多可以包含 64 項元素。在 SET 元素中值被儲存為一個分離的“位”序列，這些“位”表示與它相對應的元素。“位”是建立有序元素集合的一種簡單而有效的方式。並且它還去除了重複的元素，所以 SET 型別中不可能包含兩個相同的元素。

　　希望從 SET 型別欄位中找出非法的記錄只需查詢包含空字串或二進位制值為 0 的行。

六、使用JDBC訪問MySQL

6.1、下載驅動

6.2、JDBC訪問MySQL

示例一：

package jdbctest;
import java.math.BigDecimal;

import java.sql.*;

import java.util.Scanner;
public class GoodsDao {
</span><span style="color: rgba(0, 0, 255, 1)">static</span><span style="color: rgba(0, 0, 0, 1)"> {
    </span><span style="color: rgba(0, 0, 255, 1)">try</span><span style="color: rgba(0, 0, 0, 1)"> {
        </span><span style="color: rgba(0, 128, 0, 1)">/*</span><span style="color: rgba(0, 128, 0, 1)">載入驅動</span><span style="color: rgba(0, 128, 0, 1)">*/</span><span style="color: rgba(0, 0, 0, 1)">
        Class.forName(</span>"com.mysql.jdbc.Driver"<span style="color: rgba(0, 0, 0, 1)">);
    } </span><span style="color: rgba(0, 0, 255, 1)">catch</span><span style="color: rgba(0, 0, 0, 1)"> (ClassNotFoundException e) {
        e.printStackTrace();
    }
}

</span><span style="color: rgba(0, 0, 255, 1)">public</span> <span style="color: rgba(0, 0, 255, 1)">static</span> <span style="color: rgba(0, 0, 255, 1)">void</span><span style="color: rgba(0, 0, 0, 1)"> main(String[] args) {
    </span><span style="color: rgba(0, 128, 0, 1)">/**</span><span style="color: rgba(0, 128, 0, 1)">新增</span><span style="color: rgba(0, 128, 0, 1)">*/</span><span style="color: rgba(0, 0, 0, 1)">
    insert();
    </span><span style="color: rgba(0, 128, 0, 1)">/**</span><span style="color: rgba(0, 128, 0, 1)">查詢</span><span style="color: rgba(0, 128, 0, 1)">*/</span><span style="color: rgba(0, 0, 0, 1)">
    select();
}

</span><span style="color: rgba(0, 128, 0, 1)">/**</span><span style="color: rgba(0, 128, 0, 1)">查詢</span><span style="color: rgba(0, 128, 0, 1)">*/</span>
<span style="color: rgba(0, 0, 255, 1)">private</span> <span style="color: rgba(0, 0, 255, 1)">static</span> <span style="color: rgba(0, 0, 255, 1)">void</span><span style="color: rgba(0, 0, 0, 1)"> select() {
    </span><span style="color: rgba(0, 0, 255, 1)">try</span><span style="color: rgba(0, 0, 0, 1)"> {
        </span><span style="color: rgba(0, 128, 0, 1)">/**</span><span style="color: rgba(0, 128, 0, 1)">獲得連線物件</span><span style="color: rgba(0, 128, 0, 1)">*/</span><span style="color: rgba(0, 0, 0, 1)">
        Connection conn </span>= DriverManager.getConnection("jdbc:mysql://localhost:3306/nfmall?useUnicode=true&amp;characterEncoding=UTF-8", "root", "123"<span style="color: rgba(0, 0, 0, 1)">);

        </span><span style="color: rgba(0, 128, 0, 1)">/**</span><span style="color: rgba(0, 128, 0, 1)">建立sql命令物件</span><span style="color: rgba(0, 128, 0, 1)">*/</span><span style="color: rgba(0, 0, 0, 1)">
        PreparedStatement statement</span>=conn.prepareStatement("SELECT goods.id, goods.title, goods.category_id, goods.add_date, goods.picture, goods.state, goods.details, goods.price, category.`name`, category.parentId FROM goods INNER JOIN category ON goods.category_id = category.id where price&gt;=?"<span style="color: rgba(0, 0, 0, 1)">);
        </span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)">設定引數</span>
        statement.setInt(1,1000<span style="color: rgba(0, 0, 0, 1)">);
        </span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)">執行並獲得結果集</span>
        ResultSet result=<span style="color: rgba(0, 0, 0, 1)">statement.executeQuery();
        </span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)">遍歷結果集</span>
        <span style="color: rgba(0, 0, 255, 1)">while</span><span style="color: rgba(0, 0, 0, 1)"> (result.next()){
            </span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)">在當前行根據列名獲得資料</span>
            String title=result .getString("title"<span style="color: rgba(0, 0, 0, 1)">);
            BigDecimal price</span>=result.getBigDecimal("price"<span style="color: rgba(0, 0, 0, 1)">);
            System.out.println(title</span>+"\t"+<span style="color: rgba(0, 0, 0, 1)">price);
        }

        </span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)">關閉</span>

            result.close();

statement.close();

conn.close();

} catch (Exception e) {

e.printStackTrace();

}

}
</span><span style="color: rgba(0, 128, 0, 1)">/**</span><span style="color: rgba(0, 128, 0, 1)">新增</span><span style="color: rgba(0, 128, 0, 1)">*/</span>
<span style="color: rgba(0, 0, 255, 1)">private</span> <span style="color: rgba(0, 0, 255, 1)">static</span> <span style="color: rgba(0, 0, 255, 1)">void</span><span style="color: rgba(0, 0, 0, 1)"> insert() {
    </span><span style="color: rgba(0, 0, 255, 1)">try</span><span style="color: rgba(0, 0, 0, 1)"> {
        </span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)">輸入用的掃描器</span>
        Scanner input=<span style="color: rgba(0, 0, 255, 1)">new</span><span style="color: rgba(0, 0, 0, 1)"> Scanner(System.in);

        </span><span style="color: rgba(0, 128, 0, 1)">/**</span><span style="color: rgba(0, 128, 0, 1)">獲得連線物件</span><span style="color: rgba(0, 128, 0, 1)">*/</span><span style="color: rgba(0, 0, 0, 1)">
        Connection conn </span>= DriverManager.getConnection("jdbc:mysql://localhost:3306/nfmall?useUnicode=true&amp;characterEncoding=UTF-8", "root", "123"<span style="color: rgba(0, 0, 0, 1)">);

        </span><span style="color: rgba(0, 128, 0, 1)">/**</span><span style="color: rgba(0, 128, 0, 1)">建立sql命令物件</span><span style="color: rgba(0, 128, 0, 1)">*/</span><span style="color: rgba(0, 0, 0, 1)">
        PreparedStatement statement</span>=conn.prepareStatement("insert into goods(title,category_id,picture,price,details,state) VALUES(?,?,?,?,?,default);"<span style="color: rgba(0, 0, 0, 1)">);

        System.out.print(</span>"名稱："<span style="color: rgba(0, 0, 0, 1)">);
        String title</span>=<span style="color: rgba(0, 0, 0, 1)">input.next();
        System.out.print(</span>"型別："<span style="color: rgba(0, 0, 0, 1)">);
        </span><span style="color: rgba(0, 0, 255, 1)">int</span> cateId=<span style="color: rgba(0, 0, 0, 1)">input.nextInt();
        System.out.print(</span>"圖片："<span style="color: rgba(0, 0, 0, 1)">);
        String picture</span>=<span style="color: rgba(0, 0, 0, 1)">input.next();
        System.out.print(</span>"價格："<span style="color: rgba(0, 0, 0, 1)">);
        BigDecimal price</span>=<span style="color: rgba(0, 0, 0, 1)">input.nextBigDecimal();
        System.out.print(</span>"詳細："<span style="color: rgba(0, 0, 0, 1)">);
        String details</span>=<span style="color: rgba(0, 0, 0, 1)">input.next();

        </span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)">設定引數</span>
        statement.setString(1<span style="color: rgba(0, 0, 0, 1)">,title);
        statement.setInt(</span>2<span style="color: rgba(0, 0, 0, 1)">,cateId);
        statement.setString(</span>3<span style="color: rgba(0, 0, 0, 1)">,picture);
        statement.setBigDecimal(</span>4<span style="color: rgba(0, 0, 0, 1)">,price);
        statement.setString(</span>5<span style="color: rgba(0, 0, 0, 1)">,details);

        </span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)">執行並獲得影響行數</span>
        <span style="color: rgba(0, 0, 255, 1)">int</span> rows=<span style="color: rgba(0, 0, 0, 1)">statement.executeUpdate();

        System.out.println(</span>"執行："+(rows&gt;0?"成功":"失敗"<span style="color: rgba(0, 0, 0, 1)">));

        </span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)">關閉</span>

            statement.close();

conn.close();

} catch (Exception e) {

e.printStackTrace();

}

}
}

結果：

JDBC工具類（帶簡單對映）：

package com.zhangguo.utils;
import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.ResultSetMetaData;

import java.sql.SQLException;

import java.sql.Statement;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;
public class JDBCUtils {
</span><span style="color: rgba(0, 0, 255, 1)">public</span> <span style="color: rgba(0, 0, 255, 1)">static</span> String DRIVER = "com.microsoft.sqlserver.jdbc.SQLServerDriver"<span style="color: rgba(0, 0, 0, 1)">;
</span><span style="color: rgba(0, 0, 255, 1)">public</span> <span style="color: rgba(0, 0, 255, 1)">static</span> String URL = "jdbc:sqlserver://localhost:1433;databasename=pubs"<span style="color: rgba(0, 0, 0, 1)">;
</span><span style="color: rgba(0, 0, 255, 1)">public</span> <span style="color: rgba(0, 0, 255, 1)">static</span> String USER_NAME = "sa"<span style="color: rgba(0, 0, 0, 1)">;
</span><span style="color: rgba(0, 0, 255, 1)">public</span> <span style="color: rgba(0, 0, 255, 1)">static</span> String PASSWORD = "sa"<span style="color: rgba(0, 0, 0, 1)">;

</span><span style="color: rgba(0, 0, 255, 1)">static</span><span style="color: rgba(0, 0, 0, 1)"> {
    </span><span style="color: rgba(0, 0, 255, 1)">try</span><span style="color: rgba(0, 0, 0, 1)"> {
        Class.forName(DRIVER);
    } </span><span style="color: rgba(0, 0, 255, 1)">catch</span><span style="color: rgba(0, 0, 0, 1)"> (ClassNotFoundException e) {
        e.printStackTrace();
    }
}

</span><span style="color: rgba(0, 0, 255, 1)">private</span><span style="color: rgba(0, 0, 0, 1)"> JDBCUtils() {

}

</span><span style="color: rgba(0, 128, 0, 1)">/**</span><span style="color: rgba(0, 128, 0, 1)">
 * Get connection
 * 
 * </span><span style="color: rgba(128, 128, 128, 1)">@return</span>
 <span style="color: rgba(0, 128, 0, 1)">*/</span>
<span style="color: rgba(0, 0, 255, 1)">public</span> <span style="color: rgba(0, 0, 255, 1)">static</span><span style="color: rgba(0, 0, 0, 1)"> Connection getconnnection() {
    Connection con </span>= <span style="color: rgba(0, 0, 255, 1)">null</span><span style="color: rgba(0, 0, 0, 1)">;
    </span><span style="color: rgba(0, 0, 255, 1)">try</span><span style="color: rgba(0, 0, 0, 1)"> {
        con </span>=<span style="color: rgba(0, 0, 0, 1)"> DriverManager.getConnection(URL, USER_NAME, PASSWORD);
    } </span><span style="color: rgba(0, 0, 255, 1)">catch</span><span style="color: rgba(0, 0, 0, 1)"> (SQLException e) {
        e.printStackTrace();
    }
    </span><span style="color: rgba(0, 0, 255, 1)">return</span><span style="color: rgba(0, 0, 0, 1)"> con;
}

</span><span style="color: rgba(0, 128, 0, 1)">/**</span><span style="color: rgba(0, 128, 0, 1)">
 * Close connection
 * 
 * </span><span style="color: rgba(128, 128, 128, 1)">@param</span><span style="color: rgba(0, 128, 0, 1)"> rs
 * </span><span style="color: rgba(128, 128, 128, 1)">@param</span><span style="color: rgba(0, 128, 0, 1)"> st
 * </span><span style="color: rgba(128, 128, 128, 1)">@param</span><span style="color: rgba(0, 128, 0, 1)"> con
 </span><span style="color: rgba(0, 128, 0, 1)">*/</span>
<span style="color: rgba(0, 0, 255, 1)">public</span> <span style="color: rgba(0, 0, 255, 1)">static</span> <span style="color: rgba(0, 0, 255, 1)">void</span><span style="color: rgba(0, 0, 0, 1)"> close(ResultSet rs, Statement st, Connection con) {
    </span><span style="color: rgba(0, 0, 255, 1)">try</span><span style="color: rgba(0, 0, 0, 1)"> {
        </span><span style="color: rgba(0, 0, 255, 1)">try</span><span style="color: rgba(0, 0, 0, 1)"> {
            </span><span style="color: rgba(0, 0, 255, 1)">if</span> (rs != <span style="color: rgba(0, 0, 255, 1)">null</span><span style="color: rgba(0, 0, 0, 1)">) {
                rs.close();
            }
        } </span><span style="color: rgba(0, 0, 255, 1)">finally</span><span style="color: rgba(0, 0, 0, 1)"> {
            </span><span style="color: rgba(0, 0, 255, 1)">try</span><span style="color: rgba(0, 0, 0, 1)"> {
                </span><span style="color: rgba(0, 0, 255, 1)">if</span> (st != <span style="color: rgba(0, 0, 255, 1)">null</span><span style="color: rgba(0, 0, 0, 1)">) {
                    st.close();
                }
            } </span><span style="color: rgba(0, 0, 255, 1)">finally</span><span style="color: rgba(0, 0, 0, 1)"> {
                </span><span style="color: rgba(0, 0, 255, 1)">if</span> (con != <span style="color: rgba(0, 0, 255, 1)">null</span><span style="color: rgba(0, 0, 0, 1)">)
                    con.close();
            }
        }
    } </span><span style="color: rgba(0, 0, 255, 1)">catch</span><span style="color: rgba(0, 0, 0, 1)"> (SQLException e) {
        e.printStackTrace();
    }
}

</span><span style="color: rgba(0, 128, 0, 1)">/**</span><span style="color: rgba(0, 128, 0, 1)">
 * Close connection
 * 
 * </span><span style="color: rgba(128, 128, 128, 1)">@param</span><span style="color: rgba(0, 128, 0, 1)"> rs
 </span><span style="color: rgba(0, 128, 0, 1)">*/</span>
<span style="color: rgba(0, 0, 255, 1)">public</span> <span style="color: rgba(0, 0, 255, 1)">static</span> <span style="color: rgba(0, 0, 255, 1)">void</span><span style="color: rgba(0, 0, 0, 1)"> close(ResultSet rs) {
    Statement st </span>= <span style="color: rgba(0, 0, 255, 1)">null</span><span style="color: rgba(0, 0, 0, 1)">;
    Connection con </span>= <span style="color: rgba(0, 0, 255, 1)">null</span><span style="color: rgba(0, 0, 0, 1)">;
    </span><span style="color: rgba(0, 0, 255, 1)">try</span><span style="color: rgba(0, 0, 0, 1)"> {
        </span><span style="color: rgba(0, 0, 255, 1)">try</span><span style="color: rgba(0, 0, 0, 1)"> {
            </span><span style="color: rgba(0, 0, 255, 1)">if</span> (rs != <span style="color: rgba(0, 0, 255, 1)">null</span><span style="color: rgba(0, 0, 0, 1)">) {
                st </span>=<span style="color: rgba(0, 0, 0, 1)"> rs.getStatement();
                rs.close();
            }
        } </span><span style="color: rgba(0, 0, 255, 1)">finally</span><span style="color: rgba(0, 0, 0, 1)"> {
            </span><span style="color: rgba(0, 0, 255, 1)">try</span><span style="color: rgba(0, 0, 0, 1)"> {
                </span><span style="color: rgba(0, 0, 255, 1)">if</span> (st != <span style="color: rgba(0, 0, 255, 1)">null</span><span style="color: rgba(0, 0, 0, 1)">) {
                    con </span>=<span style="color: rgba(0, 0, 0, 1)"> st.getConnection();
                    st.close();
                }
            } </span><span style="color: rgba(0, 0, 255, 1)">finally</span><span style="color: rgba(0, 0, 0, 1)"> {
                </span><span style="color: rgba(0, 0, 255, 1)">if</span> (con != <span style="color: rgba(0, 0, 255, 1)">null</span><span style="color: rgba(0, 0, 0, 1)">) {
                    con.close();
                }
            }
        }
    } </span><span style="color: rgba(0, 0, 255, 1)">catch</span><span style="color: rgba(0, 0, 0, 1)"> (SQLException e) {
        e.printStackTrace();
    }
}

</span><span style="color: rgba(0, 128, 0, 1)">/**</span><span style="color: rgba(0, 128, 0, 1)">
 * Close connection
 * 
 * </span><span style="color: rgba(128, 128, 128, 1)">@param</span><span style="color: rgba(0, 128, 0, 1)"> st
 * </span><span style="color: rgba(128, 128, 128, 1)">@param</span><span style="color: rgba(0, 128, 0, 1)"> con
 </span><span style="color: rgba(0, 128, 0, 1)">*/</span>
<span style="color: rgba(0, 0, 255, 1)">public</span> <span style="color: rgba(0, 0, 255, 1)">static</span> <span style="color: rgba(0, 0, 255, 1)">void</span><span style="color: rgba(0, 0, 0, 1)"> close(Statement st, Connection con) {
    </span><span style="color: rgba(0, 0, 255, 1)">try</span><span style="color: rgba(0, 0, 0, 1)"> {
        </span><span style="color: rgba(0, 0, 255, 1)">try</span><span style="color: rgba(0, 0, 0, 1)"> {
            </span><span style="color: rgba(0, 0, 255, 1)">if</span> (st != <span style="color: rgba(0, 0, 255, 1)">null</span><span style="color: rgba(0, 0, 0, 1)">) {
                st.close();
            }
        } </span><span style="color: rgba(0, 0, 255, 1)">finally</span><span style="color: rgba(0, 0, 0, 1)"> {
            </span><span style="color: rgba(0, 0, 255, 1)">if</span> (con != <span style="color: rgba(0, 0, 255, 1)">null</span><span style="color: rgba(0, 0, 0, 1)">)
                con.close();
        }
    } </span><span style="color: rgba(0, 0, 255, 1)">catch</span><span style="color: rgba(0, 0, 0, 1)"> (SQLException e) {
        e.printStackTrace();
    }
}

</span><span style="color: rgba(0, 128, 0, 1)">/**</span><span style="color: rgba(0, 128, 0, 1)">
 * insert/update/delete
 * 
 * </span><span style="color: rgba(128, 128, 128, 1)">@param</span><span style="color: rgba(0, 128, 0, 1)"> sql
 * </span><span style="color: rgba(128, 128, 128, 1)">@param</span><span style="color: rgba(0, 128, 0, 1)"> args
 * </span><span style="color: rgba(128, 128, 128, 1)">@return</span>
 <span style="color: rgba(0, 128, 0, 1)">*/</span>
<span style="color: rgba(0, 0, 255, 1)">public</span> <span style="color: rgba(0, 0, 255, 1)">static</span> <span style="color: rgba(0, 0, 255, 1)">int</span><span style="color: rgba(0, 0, 0, 1)"> update(String sql, Object... args) {
    </span><span style="color: rgba(0, 0, 255, 1)">int</span> result = 0<span style="color: rgba(0, 0, 0, 1)">;
    Connection con </span>=<span style="color: rgba(0, 0, 0, 1)"> getconnnection();
    PreparedStatement ps </span>= <span style="color: rgba(0, 0, 255, 1)">null</span><span style="color: rgba(0, 0, 0, 1)">;
    </span><span style="color: rgba(0, 0, 255, 1)">try</span><span style="color: rgba(0, 0, 0, 1)"> {
        ps </span>=<span style="color: rgba(0, 0, 0, 1)"> con.prepareStatement(sql);
        </span><span style="color: rgba(0, 0, 255, 1)">if</span> (args != <span style="color: rgba(0, 0, 255, 1)">null</span><span style="color: rgba(0, 0, 0, 1)">) {
            </span><span style="color: rgba(0, 0, 255, 1)">for</span> (<span style="color: rgba(0, 0, 255, 1)">int</span> i = 0; i &lt; args.length; i++<span style="color: rgba(0, 0, 0, 1)">) {
                ps.setObject((i </span>+ 1<span style="color: rgba(0, 0, 0, 1)">), args[i]);
            }
        }
        result </span>=<span style="color: rgba(0, 0, 0, 1)"> ps.executeUpdate();
    } </span><span style="color: rgba(0, 0, 255, 1)">catch</span><span style="color: rgba(0, 0, 0, 1)"> (SQLException e) {
        e.printStackTrace();
    } </span><span style="color: rgba(0, 0, 255, 1)">finally</span><span style="color: rgba(0, 0, 0, 1)"> {
        close(ps, con);
    }

    </span><span style="color: rgba(0, 0, 255, 1)">return</span><span style="color: rgba(0, 0, 0, 1)"> result;
}

</span><span style="color: rgba(0, 128, 0, 1)">/**</span><span style="color: rgba(0, 128, 0, 1)">
 * query, because need to manually close the resource, so not recommended
 * for use it
 * 
 * </span><span style="color: rgba(128, 128, 128, 1)">@param</span><span style="color: rgba(0, 128, 0, 1)"> sql
 * </span><span style="color: rgba(128, 128, 128, 1)">@param</span><span style="color: rgba(0, 128, 0, 1)"> args
 * </span><span style="color: rgba(128, 128, 128, 1)">@return</span><span style="color: rgba(0, 128, 0, 1)"> ResultSet
 </span><span style="color: rgba(0, 128, 0, 1)">*/</span><span style="color: rgba(0, 0, 0, 1)">
@Deprecated
</span><span style="color: rgba(0, 0, 255, 1)">public</span> <span style="color: rgba(0, 0, 255, 1)">static</span><span style="color: rgba(0, 0, 0, 1)"> ResultSet query(String sql, Object... args) {
    ResultSet result </span>= <span style="color: rgba(0, 0, 255, 1)">null</span><span style="color: rgba(0, 0, 0, 1)">;
    Connection con </span>=<span style="color: rgba(0, 0, 0, 1)"> getconnnection();
    PreparedStatement ps </span>= <span style="color: rgba(0, 0, 255, 1)">null</span><span style="color: rgba(0, 0, 0, 1)">;
    </span><span style="color: rgba(0, 0, 255, 1)">try</span><span style="color: rgba(0, 0, 0, 1)"> {
        ps </span>=<span style="color: rgba(0, 0, 0, 1)"> con.prepareStatement(sql);
        </span><span style="color: rgba(0, 0, 255, 1)">if</span> (args != <span style="color: rgba(0, 0, 255, 1)">null</span><span style="color: rgba(0, 0, 0, 1)">) {
            </span><span style="color: rgba(0, 0, 255, 1)">for</span> (<span style="color: rgba(0, 0, 255, 1)">int</span> i = 0; i &lt; args.length; i++<span style="color: rgba(0, 0, 0, 1)">) {
                ps.setObject((i </span>+ 1<span style="color: rgba(0, 0, 0, 1)">), args[i]);
            }
        }
        result </span>=<span style="color: rgba(0, 0, 0, 1)"> ps.executeQuery();
    } </span><span style="color: rgba(0, 0, 255, 1)">catch</span><span style="color: rgba(0, 0, 0, 1)"> (SQLException e) {
        e.printStackTrace();
    }
    </span><span style="color: rgba(0, 0, 255, 1)">return</span><span style="color: rgba(0, 0, 0, 1)"> result;
}

</span><span style="color: rgba(0, 128, 0, 1)">/**</span><span style="color: rgba(0, 128, 0, 1)">
 * Query a single record
 * 
 * </span><span style="color: rgba(128, 128, 128, 1)">@param</span><span style="color: rgba(0, 128, 0, 1)"> sql
 * </span><span style="color: rgba(128, 128, 128, 1)">@param</span><span style="color: rgba(0, 128, 0, 1)"> args
 * </span><span style="color: rgba(128, 128, 128, 1)">@return</span><span style="color: rgba(0, 128, 0, 1)"> Map&lt;String,Object&gt;
 </span><span style="color: rgba(0, 128, 0, 1)">*/</span>
<span style="color: rgba(0, 0, 255, 1)">public</span> <span style="color: rgba(0, 0, 255, 1)">static</span> Map&lt;String, Object&gt;<span style="color: rgba(0, 0, 0, 1)"> queryForMap(String sql, Object... args) {
    Map</span>&lt;String, Object&gt; result = <span style="color: rgba(0, 0, 255, 1)">new</span> HashMap&lt;String, Object&gt;<span style="color: rgba(0, 0, 0, 1)">();
    List</span>&lt;Map&lt;String, Object&gt;&gt; list =<span style="color: rgba(0, 0, 0, 1)"> queryForList(sql, args);
    </span><span style="color: rgba(0, 0, 255, 1)">if</span> (list.size() &gt; 0<span style="color: rgba(0, 0, 0, 1)">) {
        result </span>= list.get(0<span style="color: rgba(0, 0, 0, 1)">);
    }
    </span><span style="color: rgba(0, 0, 255, 1)">return</span><span style="color: rgba(0, 0, 0, 1)"> result;
}

</span><span style="color: rgba(0, 128, 0, 1)">/**</span><span style="color: rgba(0, 128, 0, 1)">
 * Query a single record
 * 
 * </span><span style="color: rgba(128, 128, 128, 1)">@param</span><span style="color: rgba(0, 128, 0, 1)"> sql
 * </span><span style="color: rgba(128, 128, 128, 1)">@param</span><span style="color: rgba(0, 128, 0, 1)"> args
 * </span><span style="color: rgba(128, 128, 128, 1)">@return</span><span style="color: rgba(0, 128, 0, 1)"> &lt;T&gt;
 </span><span style="color: rgba(0, 128, 0, 1)">*/</span>
<span style="color: rgba(0, 0, 255, 1)">public</span> <span style="color: rgba(0, 0, 255, 1)">static</span> &lt;T&gt; T queryForObject(String sql, Class&lt;T&gt;<span style="color: rgba(0, 0, 0, 1)"> clz, Object... args) {
    T result </span>= <span style="color: rgba(0, 0, 255, 1)">null</span><span style="color: rgba(0, 0, 0, 1)">;
    List</span>&lt;T&gt; list =<span style="color: rgba(0, 0, 0, 1)"> queryForList(sql, clz, args);
    </span><span style="color: rgba(0, 0, 255, 1)">if</span> (list.size() &gt; 0<span style="color: rgba(0, 0, 0, 1)">) {
        result </span>= list.get(0<span style="color: rgba(0, 0, 0, 1)">);
    }
    </span><span style="color: rgba(0, 0, 255, 1)">return</span><span style="color: rgba(0, 0, 0, 1)"> result;
}

</span><span style="color: rgba(0, 128, 0, 1)">/**</span><span style="color: rgba(0, 128, 0, 1)">
 * Query a single record
 * 
 * </span><span style="color: rgba(128, 128, 128, 1)">@param</span><span style="color: rgba(0, 128, 0, 1)"> sql
 * </span><span style="color: rgba(128, 128, 128, 1)">@param</span><span style="color: rgba(0, 128, 0, 1)"> args
 * </span><span style="color: rgba(128, 128, 128, 1)">@return</span><span style="color: rgba(0, 128, 0, 1)"> List&lt;Map&lt;String,Object&gt;&gt;
 </span><span style="color: rgba(0, 128, 0, 1)">*/</span>
<span style="color: rgba(0, 0, 255, 1)">public</span> <span style="color: rgba(0, 0, 255, 1)">static</span> List&lt;Map&lt;String, Object&gt;&gt;<span style="color: rgba(0, 0, 0, 1)"> queryForList(String sql, Object... args) {
    List</span>&lt;Map&lt;String, Object&gt;&gt; result = <span style="color: rgba(0, 0, 255, 1)">new</span> ArrayList&lt;Map&lt;String, Object&gt;&gt;<span style="color: rgba(0, 0, 0, 1)">();
    Connection con </span>= <span style="color: rgba(0, 0, 255, 1)">null</span><span style="color: rgba(0, 0, 0, 1)">;
    ResultSet rs </span>= <span style="color: rgba(0, 0, 255, 1)">null</span><span style="color: rgba(0, 0, 0, 1)">;
    PreparedStatement ps </span>= <span style="color: rgba(0, 0, 255, 1)">null</span><span style="color: rgba(0, 0, 0, 1)">;
    </span><span style="color: rgba(0, 0, 255, 1)">try</span><span style="color: rgba(0, 0, 0, 1)"> {
        con </span>=<span style="color: rgba(0, 0, 0, 1)"> getconnnection();
        ps </span>=<span style="color: rgba(0, 0, 0, 1)"> con.prepareStatement(sql);
        </span><span style="color: rgba(0, 0, 255, 1)">if</span> (args != <span style="color: rgba(0, 0, 255, 1)">null</span><span style="color: rgba(0, 0, 0, 1)">) {
            </span><span style="color: rgba(0, 0, 255, 1)">for</span> (<span style="color: rgba(0, 0, 255, 1)">int</span> i = 0; i &lt; args.length; i++<span style="color: rgba(0, 0, 0, 1)">) {
                ps.setObject((i </span>+ 1<span style="color: rgba(0, 0, 0, 1)">), args[i]);
            }
        }
        rs </span>=<span style="color: rgba(0, 0, 0, 1)"> ps.executeQuery();
        ResultSetMetaData rsmd </span>=<span style="color: rgba(0, 0, 0, 1)"> rs.getMetaData();
        </span><span style="color: rgba(0, 0, 255, 1)">int</span> columnCount =<span style="color: rgba(0, 0, 0, 1)"> rsmd.getColumnCount();
        </span><span style="color: rgba(0, 0, 255, 1)">while</span><span style="color: rgba(0, 0, 0, 1)"> (rs.next()) {
            Map</span>&lt;String, Object&gt; map = <span style="color: rgba(0, 0, 255, 1)">new</span> HashMap&lt;String, Object&gt;<span style="color: rgba(0, 0, 0, 1)">();
            </span><span style="color: rgba(0, 0, 255, 1)">for</span> (<span style="color: rgba(0, 0, 255, 1)">int</span> i = 1; i &lt;= columnCount; i++<span style="color: rgba(0, 0, 0, 1)">) {
                map.put(rsmd.getColumnLabel(i), rs.getObject(i));
            }
            result.add(map);
        }
    } </span><span style="color: rgba(0, 0, 255, 1)">catch</span><span style="color: rgba(0, 0, 0, 1)"> (SQLException e) {
        e.printStackTrace();
    } </span><span style="color: rgba(0, 0, 255, 1)">finally</span><span style="color: rgba(0, 0, 0, 1)"> {
        close(rs, ps, con);
    }
    </span><span style="color: rgba(0, 0, 255, 1)">return</span><span style="color: rgba(0, 0, 0, 1)"> result;
}

</span><span style="color: rgba(0, 128, 0, 1)">/**</span><span style="color: rgba(0, 128, 0, 1)">
 * Query a single record
 * 
 * </span><span style="color: rgba(128, 128, 128, 1)">@param</span><span style="color: rgba(0, 128, 0, 1)"> sql
 * </span><span style="color: rgba(128, 128, 128, 1)">@param</span><span style="color: rgba(0, 128, 0, 1)"> args
 * </span><span style="color: rgba(128, 128, 128, 1)">@return</span><span style="color: rgba(0, 128, 0, 1)"> List&lt;T&gt;
 </span><span style="color: rgba(0, 128, 0, 1)">*/</span>
<span style="color: rgba(0, 0, 255, 1)">public</span> <span style="color: rgba(0, 0, 255, 1)">static</span> &lt;T&gt; List&lt;T&gt; queryForList(String sql, Class&lt;T&gt;<span style="color: rgba(0, 0, 0, 1)"> clz, Object... args) {
    List</span>&lt;T&gt; result = <span style="color: rgba(0, 0, 255, 1)">new</span> ArrayList&lt;T&gt;<span style="color: rgba(0, 0, 0, 1)">();
    Connection con </span>= <span style="color: rgba(0, 0, 255, 1)">null</span><span style="color: rgba(0, 0, 0, 1)">;
    PreparedStatement ps </span>= <span style="color: rgba(0, 0, 255, 1)">null</span><span style="color: rgba(0, 0, 0, 1)">;
    ResultSet rs </span>= <span style="color: rgba(0, 0, 255, 1)">null</span><span style="color: rgba(0, 0, 0, 1)">;
    </span><span style="color: rgba(0, 0, 255, 1)">try</span><span style="color: rgba(0, 0, 0, 1)"> {
        con </span>=<span style="color: rgba(0, 0, 0, 1)"> getconnnection();
        ps </span>=<span style="color: rgba(0, 0, 0, 1)"> con.prepareStatement(sql);
        </span><span style="color: rgba(0, 0, 255, 1)">if</span> (args != <span style="color: rgba(0, 0, 255, 1)">null</span><span style="color: rgba(0, 0, 0, 1)">) {
            </span><span style="color: rgba(0, 0, 255, 1)">for</span> (<span style="color: rgba(0, 0, 255, 1)">int</span> i = 0; i &lt; args.length; i++<span style="color: rgba(0, 0, 0, 1)">) {
                ps.setObject((i </span>+ 1<span style="color: rgba(0, 0, 0, 1)">), args[i]);
            }
        }
        rs </span>=<span style="color: rgba(0, 0, 0, 1)"> ps.executeQuery();
        ResultSetMetaData rsmd </span>=<span style="color: rgba(0, 0, 0, 1)"> rs.getMetaData();
        </span><span style="color: rgba(0, 0, 255, 1)">int</span> columnCount =<span style="color: rgba(0, 0, 0, 1)"> rsmd.getColumnCount();
        </span><span style="color: rgba(0, 0, 255, 1)">while</span><span style="color: rgba(0, 0, 0, 1)"> (rs.next()) {
            T obj </span>=<span style="color: rgba(0, 0, 0, 1)"> clz.newInstance();
            </span><span style="color: rgba(0, 0, 255, 1)">for</span> (<span style="color: rgba(0, 0, 255, 1)">int</span> i = 1; i &lt;= columnCount; i++<span style="color: rgba(0, 0, 0, 1)">) {
                String columnName </span>=<span style="color: rgba(0, 0, 0, 1)"> rsmd.getColumnName(i);
                String methodName </span>= "set" + columnName.substring(0, 1<span style="color: rgba(0, 0, 0, 1)">).toUpperCase()
                        </span>+ columnName.substring(1<span style="color: rgba(0, 0, 0, 1)">, columnName.length());
                Method method[] </span>=<span style="color: rgba(0, 0, 0, 1)"> clz.getMethods();
                </span><span style="color: rgba(0, 0, 255, 1)">for</span><span style="color: rgba(0, 0, 0, 1)"> (Method meth : method) {
                    </span><span style="color: rgba(0, 0, 255, 1)">if</span><span style="color: rgba(0, 0, 0, 1)"> (methodName.equals(meth.getName())) {
                        meth.invoke(obj, rs.getObject(i));
                    }
                }
            }
            result.add(obj);
        }
    } </span><span style="color: rgba(0, 0, 255, 1)">catch</span><span style="color: rgba(0, 0, 0, 1)"> (InstantiationException e) {
        e.printStackTrace();
    } </span><span style="color: rgba(0, 0, 255, 1)">catch</span><span style="color: rgba(0, 0, 0, 1)"> (IllegalAccessException e) {
        e.printStackTrace();
    } </span><span style="color: rgba(0, 0, 255, 1)">catch</span><span style="color: rgba(0, 0, 0, 1)"> (SQLException e) {
        e.printStackTrace();
    } </span><span style="color: rgba(0, 0, 255, 1)">catch</span><span style="color: rgba(0, 0, 0, 1)"> (IllegalArgumentException e) {
        e.printStackTrace();
    } </span><span style="color: rgba(0, 0, 255, 1)">catch</span><span style="color: rgba(0, 0, 0, 1)"> (InvocationTargetException e) {
        e.printStackTrace();
    } </span><span style="color: rgba(0, 0, 255, 1)">finally</span><span style="color: rgba(0, 0, 0, 1)"> {
        close(rs, ps, con);
    }
    </span><span style="color: rgba(0, 0, 255, 1)">return</span><span style="color: rgba(0, 0, 0, 1)"> result;
}

}