MySQL資料庫基本知識學習筆記

阿新 • • 發佈：2020-08-02

MySQL資料庫基本知識

1、初始MySQL

1.1 資料庫分類

關係型資料庫：（SQL）

MySQL，Oracle，SQL Sever......
通過表和表之間，行和列之間的關係進行資料的儲存

非關係性資料庫：（NoSQL）

Redis......
非關係性資料庫，物件儲存，通過物件的自身屬性來決定。（例：鍵值對）

1.2 命令列操作資料庫

use 資料庫名;   --切換資料庫
show databases;   --檢視所有的資料庫
show tables;   --檢視資料庫中的表
describe 表名;   --查看錶中資訊
exit；   --退出

2、操作資料庫

操作資料庫> 操作資料庫中的表>操作資料庫中表的資料

mySql中不區分大小寫

2.1 操作資料庫

1、建立資料庫

creat database [if not exists] 資料庫名;

2、刪除資料庫

drop database [if exists] 資料庫名;

3、使用資料庫

use 資料庫名;
--如果資料庫名、表名或欄位名為特殊欄位,用``
use `資料庫名`;

2.2 資料庫的列型別

數值

tinyint 十分小的資料 1個位元組
smallint 較小的資料 2個位元組
mediumint 中等大小的資料 3個位元組
int 標準的整數 4個位元組
bigint 較大的資料 8個位元組
float 浮點數 4個位元組
double 浮點數 8個位元組
decimal 字串形式的浮點數不會有精度損失

字串

char 字串 0~255
varchar 可變字串 0~65535 常用等價於String
tinytext 微型文字 2^8-1

text 文字串 2^16-1

時間日期

data YYYY-MM-DD，日期格式
time HH：mm：ss，時間格式
datetime YYYY-MM-DD HH：mm：ss 最常用的時間格式
timestamp 時間戳，1970.01.01 00:00到現在的毫秒數

null

沒有值，未知

2.3 資料庫的欄位屬性（重點）

Unsingied：

無符號整數
聲明瞭該列不能為負數

zerofill：

0填充
不足的位數，使用0來填充

自增：

通常理解為自增，自動在上一條記錄的基礎上 +1。
通常用來設計唯一的主鍵~index，必須是整數型別。
可以自定義設計主鍵自增的起始值和步長

非空：

Null not null：

假設設定為not null，如果不給它賦值，就會報錯。
Null，如果不填寫，預設就是null。

預設：

設定預設的值
sex，預設設定為：男，如果不指定該列的值，就用預設的值。

2.4 建立資料庫

/*所有的表名、欄位名建議用``(注：``是tab鍵上的那個鍵）包裹起來
注意每一個括號以及逗號等都是英文格式的
最後一個欄位後不寫逗號*/

CREATE TABLE IF NOT EXISTS `student`(
`id` INT(4) NOT NULL AUTO_INCREMENT COMMENT '學號',
`name` VARCHAR(10) NOT NULL DEFAULT '匿名' COMMENT '姓名',
`sex` VARCHAR(3) NOT NULL DEFAULT '男' COMMENT '性別',
`password` VARCHAR(20) NOT NULL DEFAULT '000000' COMMENT '密碼',
`bith` DATETIME DEFAULT NULL COMMENT '出生日期',
`address` VARCHAR(50) DEFAULT NULL COMMENT '家庭住址',
`email` VARCHAR(50) DEFAULT NULL COMMENT '郵箱',
PRIMARY KEY(`id`)
)ENGINE = INNODB DEFAULT CHARSET = utf8

檢視建立資料庫的語句

show create database 資料庫名  --- 檢視建立資料庫的語句

檢視建立表的語句

show create table 表名   -- 檢視建立表的語句

顯示錶的結構

desc 表名

2.5 資料表的型別

-- 關於資料庫引擎
/*
INNODB  預設使用
MYISAM  早些年使用
*/

	MYISAM	INNODB
事務支援	不支援	支援
資料行鎖定	不支援	支援
外來鍵	不支援	支援
全文索引	支援	不支援
表空間大小	較小	較大，約為2倍

常規使用操作：

MYISAM：節約空間，速度較快
INNADB：安全性高，事務處理，多表多使用者操作

在物理空間存在的位置

所有的資料庫檔案都存在data目錄下，一個資料夾對應一個數據庫

本質還是檔案的儲存

MySQL引擎在物理檔案上的區別

INNODB在資料庫表中只有一個*.frm檔案，以及上級目錄下的ibdata1檔案
MYISAM對應檔案
- *.frm 表結構的定義檔案
- *.MYD 資料檔案（data）
- *.MYI 索引檔案（index）

設定資料表的字符集編碼

charset = utf8

不設定的話，會是資料庫預設的字符集編碼（不支援中文）

在my.ini中配置預設的編碼

character-set-server = utf8

修改

-- 修改表名：ALTER TABLE 舊錶名 RENAME 新表名
ALTER TABLE student RENAME teacher
-- 增加表的欄位：ALTER TABLE 表名 ADD 欄位 列屬性
ALTER TABLE teacher ADD city VARCHAR(10)

-- 修改表的欄位（重新命名，修改約束）
ALTER TABLE teacher MODIFY city INT(10)    -- 修改約束
ALTER TABLE teacher CHANGE city city1 VARCHAR(10)  -- 欄位重新命名

-- ALTER TABLE 表名 DROP 欄位名
ALTER TABLE teacher DROP city1

刪除

-- 刪除表（如果存在則刪除）
ALTER TABLE IF EXISTS teacher

所有的建立和刪除操作儘量加上判斷，以免報錯

注意點：

``欄位名，使用這個包裹
註釋 -- /**/
SQL關鍵字不區分大小寫，建議小寫
所有符號全部是英文的

3、MySQL資料管理

3.1 外來鍵（瞭解即可）

方式一：在建立表的時候，增加約束（麻煩，比較複雜）

CREATE TABLE `grade`(
`gradeid` INT(10) NOT NULL AUTO_INCREMENT COMMENT '年級id',
`gradename` VARCHAR(10) NOT NULL COMMENT '年級名字',
PRIMARY KEY(`gradeid`)
)ENGINE = INNODB DEFAULT CHARSET = utf8

-- 學生表的gradeid欄位，要去引用年級表的gradeid
-- 定義外來鍵key
-- 給這個外來鍵新增約束（執行引用）references引用

CREATE TABLE IF NOT EXISTS `student`(
`id` INT(4) NOT NULL AUTO_INCREMENT COMMENT '學號',
`name` VARCHAR(10) NOT NULL DEFAULT '匿名' COMMENT '姓名',
`sex` VARCHAR(3) NOT NULL DEFAULT '男' COMMENT '性別',
`gradeid` INT(10) NOT NULL COMMENT '學生年級',
`password` VARCHAR(20) NOT NULL DEFAULT '000000' COMMENT '密碼',
`bith` DATETIME DEFAULT NULL COMMENT '出生日期',
`address` VARCHAR(50) DEFAULT NULL COMMENT '家庭住址',
`email` VARCHAR(50) DEFAULT NULL COMMENT '郵箱',
PRIMARY KEY(`id`),
KEY `FK_gradeid` (`gradeid`),
CONSTRAINT `FK_gradeid` FOREIGN KEY (`gradeid`) REFERENCES `grade`(`gradeid`)
)ENGINE = INNODB DEFAULT CHARSET = utf8

刪除有外來鍵關係的表的時候，必須先刪除引用到自己的表（從表），再刪除自己這張表（主表）。（例：欲先刪除grade表，必須先刪除student表）

建立好資料庫後，再新增外來鍵約束

-- 在建立表的時候沒有新增外來鍵約束的情況下
ALTER TABLE `student` ADD CONSTRAINT `FK_gradeid`
FOREIGN KEY (`gradeid`) REFERENCES `grade`(`gradeid`);
-- 公式：ALTER TABLE `表名` ADD CONSTRAINT `約束名` FOREIGN KEY (`作為外來鍵的列`) REFERENCES `被引用的表`(`被引用表中被引用的列`);

以上操作都是物理外來鍵，資料庫級別的外來鍵，不建議使用（避免資料庫過多造成的困擾，這裡瞭解即可）

最佳實踐

資料庫就是單純的表，只用來存資料，只有行（資料）和列（欄位）
我們向使用多張表的資料，想用外來鍵（程式實現）

3.2 DML語言（完全記住）

資料庫的意義：資料儲存，資料管理

DML語言：資料庫操作語言

insert
update
delete

3.3 插入

insert

-- 公式：INSERT INTO `表名`(`欄位名1`，`欄位名2`，`欄位名3`...) VALUES('值1','值2','值3'...)
INSERT INTO `grade`(`gradename`) VALUES('大四')
-- 由於主鍵的自增，可以不寫（但如果不寫表的欄位，它就會一一匹配）
INSERT INTO `grade` VALUES('大三')
-- 注意：新增資料的時候，欄位名和值要一一對應

-- 新增多個值
INSERT INTO `grade`(`gradename`) VALUES('大三'),('大二'),('大一')

INSERT INTO `student`(`name`,`sex`,`gradeid`,`password`) VALUES('張三','男','5','123456')

語法：INSERT INTO 表名(欄位名1，欄位名2，欄位名3...) VALUES('值1','值2','值3'...)

注意事項：

欄位和欄位之間使用英文逗號隔開
欄位是可以省略的，但是後面的值必須要一一對應
可以同時插入多條資料，VALUES後面的值，需要用逗號隔開即可VALUES(),()

3.4 修改

update

-- 修改student表中的姓名，帶了條件
UPDATE `student` SET `name`='haha' WHERE `name`='張三';
-- 修改student表中的姓名，沒有帶條件，就會將表中所有的姓名改為haha
UPDATE `student` SET `name`='haha';
UPDATE `student` SET `name`='haha',`sex`='女' WHERE `name`='張三';
-- 語法：
--   UPDATE 表名 SET 欄位名='值2',欄位名2='值2' WHERE 條件

條件：where 子句運算子，在某個區間內修改......

操作符會返回布林值

操作符	含義	範圍	結果
=	等於	5=6	false
<>或!=	不等於	5<>6	true
>
<
>=
<=
between...and...	在某個範圍內		[1,5]
AND	&&
OR	\|\|

-- 通過多個條件定位資料,無上限
UPDATE `student` SET `name`='haha',`sex`='女' WHERE `name`='張三' AND `sex`='男';

語法：UPDATE 表名 SET 欄位名='值2',欄位名2='值2' WHERE 條件

注意：

欄位儘量都帶上``
條件，篩選的條件，如果沒有指定，則會修改所有的列
多個設定的屬性之間，使用英文逗號隔開

3.5 刪除

delete命令

語法：delete from 表名 [where 條件]

-- 刪除資料，會全部刪除，避免這樣寫，否則……刪庫跑路
DELETE FROM `student`;
-- 刪除指定資料
DELETE FROM `student` WHERE `id`=1;

TRUNCATE 命令

作用：完全清空一個數據庫表，表的索引和約束不會變

-- 清空student表
TRUNCATE `student`

delete和TRUNCATE的區別

相同點：都能刪除資料，都不會刪除表結構
不同：
- TRUNCATE重新設定自增列，計數器會歸零
- TRUNCATE不會影響事務

測試：

-- 先新建一張表並插入資料
-- 測試表
CREATE TABLE IF NOT EXISTS `test`(
`id` INT(4) NOT NULL AUTO_INCREMENT,
`name` VARCHAR(10) NOT NULL,
PRIMARY KEY(`id`)
)ENGINE=INNODB DEFAULT CHARSET=utf8

INSERT INTO `test`(`name`) VALUES('張三'),('李四'),('王五')

此時用delete刪除

DELETE FROM `test`

此時自增量沒有清零

然後再插入資料用TRUNCATE

TRUNCATE TABLE `test`

可以看到此時自動增量清零從1重新開始

DELETE刪除的問題，重啟資料庫

innoDB：自增列會重新從1開始（以為存在記憶體當中，斷電即失）
MyISAM：繼續從上一個自增量開始（存在檔案中，不會丟失）

4、DQL查詢資料（最重點）

4.1 DQL

（Data Query Language：資料查詢語言）

所有的查詢操作都用它 Select
簡單的查詢，複雜的查詢它都能做
資料庫中最核心的語言，最重要的語句
使用頻率最高的語句

select完整語法

SELECT[ALL|DISTINCT]
{*|talbe.*|[table.]field1[AS alias1][,[table.]field2[AS alias2][,…]]}
FROM table_name [as table_alias]
[left | right |inner join table_name2]  -- 聯合查詢
[WHERE…]
[GROUP BY…]   -- 按照幾個欄位來分組
[HAVING…]     -- 過濾分組的記錄必須要滿足的次要條件
[ORDER BY…]   -- 指定查詢機理按一個或多個條件排序
[limit {[offset.]row_count | row_countoffset offset}];

4.2 指定欄位查詢

當前以及之後會用到的三張表的建表及匯入一部分測試資料的SQL語句如下：

-- 建立一個學生資訊表
create table `student` (
	`studentId` int (4),
	`studentName` varchar (30),
	`sex` varchar (9),
	`gradeid` int (10),
	`password` varchar (60),
	`bith` datetime ,
	`address` varchar (150),
	`email` varchar (150)
); 
insert into `student` (`studentId`, `studentName`, `sex`, `gradeid`, `password`, `bith`, `address`, `email`) values('1','張三','男','5','123456','1950-06-07 00:00:00','浙江巴拉巴拉',NULL);
insert into `student` (`studentId`, `studentName`, `sex`, `gradeid`, `password`, `bith`, `address`, `email`) values('2','lili','女','5','456789','1840-03-09 00:00:00','上海巴拉巴拉',NULL);
insert into `student` (`studentId`, `studentName`, `sex`, `gradeid`, `password`, `bith`, `address`, `email`) values('3','Lv','男','5','456789',NULL,'',NULL);
insert into `student` (`studentId`, `studentName`, `sex`, `gradeid`, `password`, `bith`, `address`, `email`) values('4','李四','男','4','000000','1990-03-15 00:00:00','北京巴拉巴拉',NULL);
insert into `student` (`studentId`, `studentName`, `sex`, `gradeid`, `password`, `bith`, `address`, `email`) values('5','王五','男','6','000000',NULL,'上海巴拉巴拉',NULL);
insert into `student` (`studentId`, `studentName`, `sex`, `gradeid`, `password`, `bith`, `address`, `email`) values('6','辣妹','女','9','000000',NULL,'四川',NULL);
insert into `student` (`studentId`, `studentName`, `sex`, `gradeid`, `password`, `bith`, `address`, `email`) values('7','Lvvvvv','男','6','000000',NULL,NULL,NULL);

-- 建立一個學生成績表
create table `result` (
	`studentId` int (10),
	`subjectId` int (10),
	`results` int (4)
); 
insert into `result` (`studentId`, `subjectId`, `results`) values('1','101','60');
insert into `result` (`studentId`, `subjectId`, `results`) values('2','101','65');
insert into `result` (`studentId`, `subjectId`, `results`) values('3','101','70');
insert into `result` (`studentId`, `subjectId`, `results`) values('4','101','80');
insert into `result` (`studentId`, `subjectId`, `results`) values('5','101','50');
insert into `result` (`studentId`, `subjectId`, `results`) values('6','101','90');
insert into `result` (`studentId`, `subjectId`, `results`) values('1','102','75');
insert into `result` (`studentId`, `subjectId`, `results`) values('2','102','45');
insert into `result` (`studentId`, `subjectId`, `results`) values('3','102','90');
insert into `result` (`studentId`, `subjectId`, `results`) values('4','102','95');
insert into `result` (`studentId`, `subjectId`, `results`) values('5','102','85');
insert into `result` (`studentId`, `subjectId`, `results`) values('6','102','95');
insert into `result` (`studentId`, `subjectId`, `results`) values('1','103','85');
insert into `result` (`studentId`, `subjectId`, `results`) values('2','103','65');
insert into `result` (`studentId`, `subjectId`, `results`) values('4','103','78');
insert into `result` (`studentId`, `subjectId`, `results`) values('5','103','95');

-- 建立一個科目表
create table `subjects` (
	`subjectId` int (10),
	`subjectName` varchar (60)
); 
insert into `subjects` (`subjectId`, `subjectName`) values('101','語文');
insert into `subjects` (`subjectId`, `subjectName`) values('102','數學');
insert into `subjects` (`subjectId`, `subjectName`) values('103','英語');

注：後續的練習如果個人練習，對照著表練，欄位名不要寫錯即可，如果參考我以下程式碼，由於後期欄位名有所更改：以下一直到4.4聯表查詢之間的 id-->studentId,name-->studentName,subject-->subjectId

-- 查詢student表中的所有資訊
SELECT * FROM `student`

-- 查詢指定欄位
SELECT `id`,`name` FROM `student`

-- 別名，給結果起一個名字。用AS可以給欄位起別名，也可以給表起
SELECT `id` AS 學號,`name` AS 姓名 FROM `student`

-- 函式 Concat(a,b),拼接字串，將a和b拼接起來
SELECT CONCAT('姓名：',`name`) AS 學生姓名 FROM `student`

語法：SELECT 欄位...... FROM 表名

有的時候，列名字不是讀者不懂，就可以起別名：欄位名 AS 別名表名 AS 別名

去重 distinct

作用：去除SELECT查詢出來的結果中重複的資料，重複的資料只顯示一條

SELECT `id` FROM `result`  -- 這樣查詢出來的資料有大量重複
SELECT DISTINCT `id` FROM `result`  -- 用DISTINCT去除重複

語法：SELECT DISTINCT 欄位名 FROM 表名

資料庫的列（表示式）

SELECT VERSION()  -- 查詢系統版本 （函式）
SELECT 100*3-1 AS 計算結果   -- 用來計算 （表示式）
SELECT @@auto_increment_increment   -- 查詢自增的步長 （變數）

-- 讓所有學生的id加一
SELECT `id`+1 AS 加一後,`name` FROM `student`

資料庫中的表示式：文字值、列，NULL，函式，計算表示式，系統變數......

select 表示式 from 表

4.3 where條件子句

作用：檢索資料中符合條件的值

邏輯運算子

運算子	語法	描述
and &&	a and b a&&b	邏輯與
or \|\|	a or b a\|\|b	邏輯或
Not !	not a !=a	邏輯非

SELECT `id`,`name` FROM `result`;

-- And,查詢60分~100分之間的學生
SELECT `id`,`name` FROM `result`WHERE `results`>60 AND `results`<100;

-- or,查詢成績等於60或59的學生
SELECT `id`,`name` FROM `result`WHERE `results`=60 OR `results`=59;

-- not,查詢成績小於60分的學生
SELECT `id`,`name` FROM `result` WHERE NOT `results`>60;

模糊查詢：比較運算子

運算子	語法	描述
is null	a is null	如果操作符為null，結果為真
is not null	a is not null	如果操作符為not null 結果為真
between	a between b and c	若a在b和c之間，則結果為真
like	a like b	如果a匹配b，則結果為真
in	a in (a1,a2....)	假設a在a1或者a2...則結果為真

-- like
-- 查詢姓張的同學
-- like結合 %（代表0到任意個字元） _（一個字元）
SELECT `id`,`name`,`sex` FROM `student` WHERE `name` LIKE '張%'

-- 查詢姓張的但名字只有一個字的
SELECT `id`,`name`,`sex` FROM `student` WHERE `name` LIKE '張_'

-- 查詢名字中間有輝字的
SELECT `id`,`name`,`sex` FROM `student` WHERE `name` LIKE '%輝%'

-- ==========in（具體的一個或多個值）===========
SELECT `id`,`name`,`sex` FROM `student` WHERE `address` IN ('四川','上海巴拉巴拉')

-- =========null   not null===========
-- 查詢地址為空的，null或者空字串''
SELECT `id`,`name`,`sex` FROM `student` WHERE `address`='' OR `address` IS NULL

-- 查詢有出生日期的 不為空not null
 SELECT `id`,`name`,`sex` FROM `student` WHERE `bith` IS NOT NULL

4.4 連表查詢

-- ================ 聯表查詢 JOIN ====================
/*
思路：
1、分析需求，分析查詢的欄位來自哪些表，（連線查詢）
2、確定使用哪種連線查詢？
3、判斷交叉點（這兩個表中有哪些資料是相同的）
*/
-- 查詢參加了考試的同學（學號，姓名，科目id，分數）
-- ======= INNER JOIN ========
SELECT s.`id`,`name`,`subject`,`results`
FROM `student` AS s INNER JOIN `result` AS r
WHERE s.id = r.id
-- INNER JOIN查出來的是兩個表都有的

-- ======= LEFT JOIN ========
-- where可以用on,as在一定條件下可以省略，這裡可以省略
SELECT s.`id`,`name`,`subject`,`results`
FROM `student` s LEFT JOIN `result` r
ON s.id = r.id
-- LEFT JOIN查詢，只要左表即student表有的即使右邊的表即result表沒有的也會顯示出來

-- ======= RIGHT JOIN ========
SELECT s.`id`,`name`,`subject`,`results`
FROM `student` s RIGHT JOIN `result` r
ON s.id = r.id
-- RIGHT JOIN查詢，只要右表有的即使左表沒有的也會顯示出來

-- join 連線的表 on（判斷的條件） 連線查詢
-- where 等值查詢

操作	描述
Inner join	如果表中至少有一個匹配，就返回行
left join	會從左表中返回所有的值，即使右表中沒有
right join	會從右表中返回所有的值，即使左表中沒有

-- 三表查詢
-- 查詢參加了考試的學生，增加一個科目名欄位
SELECT s.`studentId`,`studentName`,`subjectId`,`subjectName`,`results`
FROM `student` s RIGHT JOIN `result` r
ON s.id = r.id
INNER JOIN `subjects` sub
ON r.`subject`=sub.`subjectId`

-- 我要從哪幾個表去查 select......
-- 從哪幾個表中查from 表  XXX JOIN 連線的表 on 交叉條件
-- 假設存在一種多表查詢，慢慢來，一個一個來，像我上面的三表查詢一樣

自連線

自己的表和自己的表連線，核心：一張表拆成兩張一樣的表

當自己的父id和對方的子id相匹配，說明自己是對方的兒子，自己屬於對方的範圍

SELECT a.`categoryName` AS '父欄目',b.`categoryName` AS '子欄目'
FROM `category` AS a,`category` AS b
WHERE a.`categoryid` = b.`pid`

4.5 分頁和排序

排序

-- ================= 分頁 limit 和排序 order by ======================

-- 排序：升序ASC   降序：DESC
SELECT s.`studentId`,`studentName`,`subjectName`,`results`
FROM `student` s INNER JOIN `result` r
ON s.`studentId` = r.`studentId`
INNER JOIN `subjects` sub
ON r.`subjectId` = sub.`subjectId`
WHERE `subjectName` = '語文'
ORDER BY `results` DESC

分頁

-- 分頁
-- 語法：LIMIT 起始值,每頁顯示的資料條數
SELECT s.`studentId`,`studentName`,`subjectName`,`results`
FROM `student` s INNER JOIN `result` r
ON s.`studentId` = r.`studentId`
INNER JOIN `subjects` sub
ON r.`subjectId` = sub.`subjectId`
ORDER BY `results` DESC
LIMIT 0,5

-- 第一頁 limit 0,5   （1-1）*5
-- 第二頁 limit 5,5    （2-1）*5
-- 第三頁 limit 10,5    （3-1）*5
-- 第N頁 limit （n-1）*pageSize,5    （n-1）*pageSize，pageSize
-- 【pageSize：頁面大小】
-- 【（n-1）*pageSize：起始值】
-- 【n：當前頁】
-- 【資料總數、頁面大小 = 總頁數】

語法：limit（查詢起始值下標，pageSize）

4.6 子查詢

where（這個值時計算出來的）

本質：在where語句中再巢狀一個select查詢

-- 查詢所有考的語文的同學的學號、科目名、成績，降序排列
-- 方式一
SELECT `studentId`,`subjectName`,`results`
FROM `result` r
INNER JOIN `subjects` sub
ON r.`subjectId` = sub.`subjectId`
WHERE `subjectName`='語文'
ORDER BY `results` DESC

-- 方式二，子查詢
-- 1.先從subject表中查出語文的`subjectId`傳給第二步
SELECT `subjectId` FROM `subjects` WHERE `subjectName`='語文'
-- 2.從成績表中查出考了語文的同學的id傳給第三步
SELECT `studentId`,`subjectId`,`results` FROM `result` 
WHERE `subjectId` = 
(SELECT `subjectId` FROM `subjects` 
WHERE `subjectName`='語文')
ORDER BY `results` DESC

-- 子查詢：查詢考了語文的前三名同學的學號、姓名
SELECT `studentId`,`studentName` FROM `student` 
WHERE `studentId` IN (SELECT `studentId` FROM `result` WHERE `subjectId` = (
SELECT `subjectId` FROM `subjects` WHERE `subjectName` = '語文')
ORDER BY `results` DESC
)LIMIT 0,3

-- 查詢考了語文的前三名的學號、姓名
SELECT s.`studentId`,`studentName` FROM `student` s
INNER JOIN `result` r
ON s.`studentId` = r.`studentId`
WHERE `subjectId` = (
SELECT `subjectId` FROM `subjects` WHERE `subjectName` = '語文'
) ORDER BY `results`
LIMIT 0,3

4.7 分組過濾

-- 查詢所有科目的平均分，最高分，最低分
-- 核心：根據科目分類
SELECT `studentId`,`subjectName`,AVG(`results`) AS 平均分,MAX(`results`) AS 最高分,MIN(`results`) AS 最低分
FROM `result` r INNER JOIN `subjects` sub
ON r.`subjectId`=sub.`subjectId`
GROUP BY r.`subjectId`
HAVING 平均分>=80

5、MySQL函式

官網：https://dev.mysql.com/doc/refman/5.7/en/func-op-summary-ref.html

5.1 常用函式

常用函式（瞭解即可，時間日期需記住）

-- ========================== 常用函式 =================================
-- 數學運算
SELECT ABS(-8)   -- 絕對值
SELECT CEILING(9.4)   -- 向上取整
SELECT FLOOR(9.4)   -- 向下取整
SELECT RAND()   -- 返回一個0~1之間的隨機數
SELECT SIGN(-10)   -- 判斷一個數的符號 0-0 負數返回-1 正數返回1

-- 字串函式
SELECT CHAR_LENGTH('hello everyone')   -- 字串長度
SELECT CONCAT('i','love','you')   -- 拼接字串
SELECT INSERT('我愛程式設計',1,2,'超級熱愛')  -- 查詢，從指定位置開始替換指定長度的字串
SELECT LOWER('LV')  -- 大寫轉小寫
SELECT UPPER('lv')   -- 小寫轉大寫
SELECT INSTR('i love you','o')   -- 返回第一次出現的子串的索引
SELECT REPLACE ('堅持就能成功','堅持','努努力')   -- 用字串替換指定字串
SELECT SUBSTR('堅持就能成功',1,3)   -- 返回指定的字串（源字串，開始擷取的位置，擷取的長度）

-- 查詢姓張的同學，將張改為章
SELECT REPLACE(`studentName` ,'張','章') FROM `student`
WHERE `studentName` LIKE '張%'

-- 時間和日期函式（記住）
SELECT CURRENT_DATE()  -- 獲取當前日期
SELECT NOW()   -- 獲取當前的時間
SELECT LOCALTIME()   -- 獲取本地時間
SELECT SYSDATE()   -- 系統時間
SELECT YEAR(NOW())
SELECT MONTH(NOW())
SELECT DAY(NOW())
-- ......

-- 系統
SELECT SYSTEM_USER()
SELECT USER()
SELECT VERSION()

5.2 聚合函式

函式名稱	描述
COUNT()	計數
SUM()	求和
AVG()	平均值
MAX()	最大值
MIN()	最小值
......	......

-- =========聚合函式============
SELECT COUNT(`bith`) FROM `student`;   -- Count(欄位),會忽略所有的null值
SELECT COUNT(*) FROM `student`;   -- Count(*) 不會忽略null值，相當於統計所有行
SELECT COUNT(1) FROM `student`;   -- Count(1) 不會忽略null值，相當於將所有行都設為1，統計1的個數
-- Count（0）統計所有為null值的行
/* 執行效率上
若列名為主鍵，則count（列名）快於count(1),不為主鍵則count（1）更快
如果多個列且沒有主鍵，count（1）快於count（*）
如果表只有一個欄位，count（*）最優
*/

5.3 資料庫級別MD5加密（擴充套件）

什麼是MD5？

主要增強演算法複雜度和不可逆性。

MD5不可逆，具體的值的MD5都是一樣的

-- ==========測試MD5 加密=============

CREATE TABLE `testmd5`(
`id` INT(4) NOT NULL,
`name` VARCHAR(50) NOT NULL,
`pwd` VARCHAR(50) NOT NULL,
PRIMARY KEY(`id`)
)ENGINE = INNODB DEFAULT CHARSET = utf8

INSERT INTO `testmd5` VALUES('1','張三','123456'),('2','李四','111111'),('3','王五','654332')

-- 加密
UPDATE `testmd5` SET `pwd`=MD5(pwd) WHERE `id`=1;
UPDATE `testmd5` SET `pwd`=MD5(pwd)

-- 插入的時候加密
INSERT INTO `testmd5` VALUES(4,'小明',MD5('123456'))

-- 如何校驗：將使用者傳遞進來的密碼，進行MD5加密，然後對比加密後的值
SELECT * FROM `testmd5` WHERE `name`='小明' AND pwd=MD5('123456')

6、事務

要麼都成功要麼都失敗

1、SQL執行 A給B轉賬 A：1000-->200 B 200

2、SQL執行 B收到A的錢 -->B 400

將一組SQL凡在一個批次中去執行

事務原則：ACID原則原子性、一致性、隔離性、永續性

參考部落格連結：https://blog.csdn.net/dengjili/article/details/82468576

原子性（Atomicity）
要麼都成功，要麼都失敗
一致性（Consistency）
事務前後資料的完整性必須保持一致。
隔離性（Isolation）
事務的隔離性是多個使用者併發訪問資料庫時，資料庫為每一個使用者開啟的事務，不能被其他事務的操作資料所幹擾，多個併發事務之間要相互隔離。
永續性（Durability）
事務一旦提交則不可逆

隔離所導致的問題

髒讀：

指一個事務讀取了另外一個事務未提交的資料。

不可重複讀：

在一個事務內讀取表中的某一行資料，多次讀取結果不同。

虛讀（幻讀）：

是指在一個事務內讀取到了別的事務插入的資料，導致前後讀取不一致。

-- ==================== 事務 ========================
-- MySQL 是預設開啟事務自動提交的
SET autocommit = 0  -- 關閉
SET autocommit = 1  -- 開啟（預設）

-- 手動處理事務
SET autommit = 0   -- 關閉自動提交

-- 事務開啟
START TRANSACTION  -- 標記一個事務的開始，從這個之後的SQL都在同一個事務內

-- 提交：持久化（成功）
COMMIT
-- 回滾：回到原來的樣子（失敗）
ROLLBACK

-- 事務結束
SET autocommit = 1   -- 開啟自動提交

SAVEPOINT 儲存點名   -- 設定一個事務的儲存點
RELEASE SAVEPOINT 儲存點名   -- 刪除儲存點

模擬銀行轉錢場景

-- ==================== 模擬事務 =======================
-- 建立一個數據庫
CREATE DATABASE `bank` CHARACTER SET utf8 COLLATE utf8_general_ci;
USE `bank`;

-- 建立一張表
CREATE TABLE `account`(
`id` INT(10) NOT NULL AUTO_INCREMENT,
`name` VARCHAR(50) NOT NULL,
`money` DECIMAL(9,2),  -- DECIMAL(9,2)表示儲存9位數字，2位小數
PRIMARY KEY (`id`)
)ENGINE = INNODB DEFAULT CHARSET = utf8

INSERT INTO `account`(`name`,`money`) VALUES ('張三',5000.00),('李四',10000.00);

SET autocommit = 0;   -- 關閉自動提交

START TRANSACTION;   -- 開啟一個事務

UPDATE `account` SET `money`=`money`-500 WHERE `name`='張三';
UPDATE `account` SET `money`=`money`+500 WHERE `name`='李四';

COMMIT  -- 成功則提交
ROLLBACK   -- 失敗則回滾

SET autocommit = 1;   -- 結束開啟自動提交

7、索引

索引是幫助MySQL高效獲取資料的資料結構。

提取句子主幹，就可以得到索引的本質：索引是資料結構。

7.1 索引的分類

在一個表中，主鍵索引只能有一個，唯一索引可以有多個

主鍵索引（PRIMARY KEY)
- 唯一標示，主鍵不可重複，只能有一個列作為主鍵
唯一索引（UNIQUE KEY）
- 避免重複的列出現，唯一索引可以重複，多個列都可標識為唯一索引
常規索引（KEY/INDEX）
- 預設的，index/key關鍵字
全文索引（FullText）
- 在特定的資料庫引擎下才有，MyISAM
- 快速定位資料

-- ==================索引===================
-- 1.在建立表的時候給欄位增加索引
-- 2.建立完畢後，增加索引


-- 顯示所有索引資訊
SHOW INDEX FROM student

-- 增加一個全文索引    （索引名）  列名
ALTER TABLE learn.student ADD FULLTEXT INDEX `studentName`(`studentName`);


-- EXPLAIN 分析SQL執行的情況
EXPLAIN SELECT * FROM `student`;

EXPLAIN SELECT * FROM `student` WHERE MATCH(`studentName`) AGAINST('張');

7.3 索引測試

小量資料索引不明顯，需要大量的資料來支撐，想測試的下夥伴可以去搜一下，這裡就不做過多的測試了。大概100萬條資料不加索引查詢資料的話，快的電腦用時1秒，然後加了索引之後用時0.001秒。

7.4 索引原則

索引不是越多越好
不要對程序變動資料索引
小資料量的表不需要索引
索引一般載入常用來查詢的欄位上

8、許可權管理和備份

8.1 使用者管理

SQL yoga視覺化管理

SQL命令操作

使用者表：mysql.user

本質：對這張表進行增刪改查

-- ====================許可權管理==================
-- 建立使用者CREATE USER 使用者名稱 IDENTIFIED BY '密碼'
CREATE USER Lv IDENTIFIED BY '123456'

-- 修改密碼（修改當前使用者密碼）
SET PASSWORD = PASSWORD('123456')

-- 修改指定使用者密碼
SET PASSWORD FOR Lv = PASSWORD('123456')

-- 重新命名 
RENAME USER Lv TO Lvvvv

-- 使用者授權
GRANT ALL PRIVILEGES ON *.* TO Lvvvv

-- 查詢許可權,如果是預設%可以不用寫，localhost則要寫@localhost
SHOW GRANTS FOR Lvvvv@localhost

-- 撤銷許可權
REMOVE ALL PRIVILEGES ON *.* FROM Lvvvv

-- 刪除使用者
DROP USER Lvvvv

8.2 MySQL 備份

為什麼要備份：

保證重要的資料不丟失
資料轉移

MySQL資料庫備份的方式

直接拷貝物理檔案
在sqlyog這樣的視覺化工具中匯出
使用命令列匯出 mysqldump

# mysqldump -h主機 -u使用者名稱 -p密碼 資料庫名 表名 >目的磁碟位置
mysqldump -hlocalhost -uroot -p123456 learn student >D:/a.sq
#多張表
# mysqldump -h主機 -u使用者名稱 -p密碼 資料庫名 表1 表2 表3 >目的磁碟位置
#匯出資料庫
#mysqldump -h主機 -u使用者名稱 -p密碼 資料庫名>目的磁碟位置

#匯入
#在登陸的情況下
#source D:/a.sql

9、規範資料庫設計

9.1 為什麼需要設計

當資料庫比較複雜的時候，我們就需要設計了

糟糕的資料庫設計：

資料冗餘，浪費空間
資料庫插入和刪除都會麻煩、異常【遮蔽使用物理外來鍵】
資料庫的效能差

良好的資料庫設計：

節省記憶體空間
保證資料庫的完整性
方便我們開發系統

軟體開發中，關於資料庫的設計

分析需求：分析業務和需要處理的資料庫的需求
概要設計：設計關係圖E-R圖

設計資料庫的步驟：（個人部落格）

收集資訊，分析需求
- 使用者表（使用者登入登出，使用者的個人資訊，寫部落格，建立分類）
- 分類表（文章分類）
- 文章表（文章的資訊）
- 評論表
- 友連結串列（友鏈資訊）
- 自定義表（系統資訊，某個關鍵字，或者一些主欄位）key:value
標示實體（把需求落在每個欄位上）
- 寫部落格：user-->blog
- 建立分類：user-->category
- 關注：user-->user
- 友鏈：links
- 評論：user-user-blog

9.2 三大正規化

為什麼需要規範化？

資訊重複
更新異常
插入異常
- 無法正常顯示資訊
刪除異常
- 丟失有效資料

三大正規化

第一正規化（1NF）

原子性：保證每一列不可再分

第二正規化（2NF）

前提：滿足第一正規化的前提下

每張表只描述一件事情

第三正規化（3NF）

前提：滿足第一正規化和第二正規化

第三正規化需要確保表中的每一列資料都和主鍵直接相關，而不能間接相關

（規範資料庫的設計）

規範性和效能的問題

阿里裡面規定關聯查詢的表不得超過三張

考慮商業化的需求和目標（成本，使用者體驗），資料庫的效能更加重要
在規範效能的問題的時候，需要適當的考慮一下規範性
故意給某些表增加一些冗餘的欄位。（從多表查詢變為單表查詢）
故意增加一些計算列（從大資料量降低為小資料量的查詢）或增加索引

10、JDBC

10.1 資料庫驅動

應用程式不能直接操作資料庫，因此，需要通過資料庫驅動來操作資料庫。

10.2 JDBC

sun公司為了簡化開發人員（對資料庫的統一）操作，提供了一個（Java操作資料庫的）規範，俗稱JDBC，這些規範的實現有具體廠商去做。

對於開發人員來說，只需要掌握JDBC即可。

10.3 第一個JDBC程式

建立測試資料庫

建立一個數據庫，在其中新建一張表並插入一些用來測試的資料，這裡我就用上面的learn資料庫下的student表。
匯入資料庫驅動

資料庫驅動可以去官網下載與自己資料庫相關的版本
連線並操作資料庫

package com.kuang;

import java.sql.*;

/**
 * @Author: Lv
 * @Description:
 * @Vision: 1.0
 * @Date: Created in 9:18 2020/7/17
 */
public class Test01 {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //1.載入驅動
        Class.forName("com.mysql.jdbc.Driver");  //固定寫法

        //2.使用者資訊和url
        //useUnicode=true&characterEncoding=utf8&useSSL=true
        String url = "jdbc:mysql://localhost:3306/learn?useUnicode=true&characterEncoding=utf8&useSSL=true";
        String username = "root";
        String password = "123456";
        //3.連線成功，資料庫物件
        Connection connection = DriverManager.getConnection(url, username, password);

        //4.執行SQL的物件
        Statement statement = connection.createStatement();

        //5.執行SQL的物件 去執行SQL 可能存在結果，檢視返回結果
        String sql = "SELECT * FROM student";

        ResultSet resultSet = statement.executeQuery(sql);

        while (resultSet.next()){
            System.out.println("id="+resultSet.getObject("studentId"));
            System.out.println("name="+resultSet.getObject("studentName"));
            System.out.println("sex="+resultSet.getObject("sex"));
            System.out.println("===================================");
        }
        //6.釋放連線
        resultSet.close();
        statement.close();
        connection.close();
    }
}

步驟總結：

1、載入驅動

2、連線資料庫 DriverManager

3、獲得執行SQL的物件 statement

4、獲得返回的結果集

5、釋放連線

DriverManager

//3.連線成功，資料庫物件
Connection connection = DriverManager.getConnection(url, username, password);

url

String url = "jdbc:mysql://localhost:3306/learn?useUnicode=true&characterEncoding=utf8&useSSL=true";

// 協議://主機地址:埠號/資料庫名?引數1&引數2&引數3

Statement 執行SQL物件 PreparedStatement

statement.executeQuery();   //執行查詢
statement.execute();   //執行所有語句
statement.executeUpdate();   //執行更新、插入、刪除語句

ResultSet 封裝了結果集

獲取指定型別的資料

resultSet.getObject();
resultSet.getString();
resultSet.getInt();
resultSet.getDouble();
resultSet.getDate();

釋放資源

//6.釋放連線
resultSet.close();
statement.close();
connection.close();

10.4 statement物件

jdbc中的statement物件用於向資料庫傳送SQL語句，完成對資料庫的增刪改查，只需要通過這個物件向資料庫傳送增刪改查的語句即可。

statement物件的executeUpdate方法，用於向資料庫傳送增、刪、改的SQL語句，executeUpdate執行完後，會返回一個整數（即增刪改語句導致了資料庫收到影響的行數）

statement.Query方法用於向資料庫傳送查詢語句，executeQuery方法返回一個ResultSet結果集

CRUD操作create

使用executeUpdate(String sql)方法完成資料的新增操作，示例操作：

Statement statement = connection.createStatement();
String sql = "insert into student(...) values(...)";
int num = statement.executeUpdate(sql)
if(num>0){
    System.out.println("插入成功");
}

CRUD操作delete

使用executeUpdate(String sql)方法完成資料刪除操作，示例如下：

Statement statement = connection.createStatement();
String sql = "delete from student where id=1";
int num = statement.executeUpdate(sql)
if(num>0){
    System.out.println("刪除成功");
}

CRUD操作update

使用executeUpdate(String sql)方法完成資料更新操作，示例如下：

Statement statement = connection.createStatement();
String sql = "update student set name='莉莉' where id=3";
int num = statement.executeUpdate(sql)
if(num>0){
    System.out.println("修改成功");
}

CRUD操作read

使用executeQuery(String sql)方法完成資料更新操作，示例如下：

Statement statement = connection.createStatement();
String sql = "SELECT * FROM student";
ResultSet resultSet = statement.executeQuery(sql);
 while (resultSet.next()){}

程式碼實現

1、先建立一個db.properies檔案存放url等

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/learn?useUnicode=true&characterEncoding=utf8&useSSL=true
username=root
password=123456

2、寫JDBCUtils工具類

package com.kuang.utils;

import java.io.IOException;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

/**
 * @Author: Lv
 * @Description:
 * @Vision: 1.0
 * @Date: Created in 11:33 2020/7/17
 */
public class JDBCUtils {

    private static String driver = null;
    private static String url = null;
    private static String username = null;
    private static String password = null;

    static {
        try {
            InputStream in = JDBCUtils.class.getClassLoader().getResourceAsStream("db.properties");
            Properties properties = new Properties();
            properties.load(in);

            driver = properties.getProperty("driver");
            url = properties.getProperty("url");
            username = properties.getProperty("username");
            password = properties.getProperty("password");

            //1.驅動只用載入一次
            Class.forName(driver);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    //獲取連線
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url, username, password);
    }

    //釋放連線資源
    public static void release(Connection conn, Statement st, ResultSet rs){
        if(rs!=null){
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(st!=null){
            try {
                st.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn!=null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

查詢實現

package com.kuang;

import com.kuang.utils.JDBCUtils;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

/**
 * @Author: Lv
 * @Description:
 * @Vision: 1.0
 * @Date: Created in 12:09 2020/7/17
 */
public class QueryTest {
    public static void main(String[] args) {

        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;

        try {
            conn = JDBCUtils.getConnection();
            st = conn.createStatement();

            String sql = "SELECT * FROM `student`";
            rs = st.executeQuery(sql);
            while (rs.next()){
                System.out.println("學號="+rs.getInt("studentId"));
                System.out.println("姓名="+rs.getString("studentName"));
                System.out.println("性別="+rs.getString("sex"));
                System.out.println("年級="+rs.getString("gradeid"));
                System.out.println("密碼="+rs.getString("password"));
                System.out.println("生日="+rs.getDate("bith"));
                System.out.println("家庭住址="+rs.getString("address"));
                System.out.println("=============================================");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JDBCUtils.release(conn,st,rs);
        }
    }
}

插入實現（更新、刪除與插入一樣，只需要改SQL語句即可）

package com.kuang;

import com.kuang.utils.JDBCUtils;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

/**
 * @Author: Lv
 * @Description:
 * @Vision: 1.0
 * @Date: Created in 11:47 2020/7/17
 */
public class InsertTest {
    public static void main(String[] args) {

        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;

        try {
            conn = JDBCUtils.getConnection();  //獲取資料庫連線
            st = conn.createStatement();   //獲取SQL的執行物件
            String sql = "INSERT INTO `student`(`studentId`,`studentName`,`sex`,`gradeid`,`password`,`bith`)" +
                    "VALUES(10,'婷婷','女','大四','123456','1998-03-15')";

            int i = st.executeUpdate(sql);
            if (i>0){
                System.out.println("插入成功");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JDBCUtils.release(conn,st,rs);
        }
    }
}

SQL注入的問題

sql存在漏洞，會被攻擊導致資料洩露（被讀取全部內容）

import com.kuang.utils.JDBCUtils;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

/**
 * @Author: Lv
 * @Description:
 * @Vision: 1.0
 * @Date: Created in 12:41 2020/7/17
 */
public class SQLProblem {
    public static void main(String[] args) {
        login(" 'or' 1=1"," 'or' 1=1");
    }

    //登陸業務
    public static void login(String name, String password){
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;

        try {
            conn = JDBCUtils.getConnection();
            st = conn.createStatement();

            //SELECT * FROM `student` WHERE `studentName`='Lv' AND `password`='456789'
            //SELECT * FROM `student` WHERE `studentName`=' 'or' 1=1' AND `password`=' 'or' 1=1'
            String sql = "SELECT * FROM `student` WHERE `studentName`='"+name+"' AND `password`='"+password+"'";
            rs = st.executeQuery(sql);
            while (rs.next()){
                System.out.println("姓名="+rs.getString("studentName"));
                System.out.println("密碼="+rs.getString("password"));
                System.out.println("=============================================");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JDBCUtils.release(conn,st,rs);
        }
    }
}

會被讀取這張表中的全部使用者資訊，如下：

10.5 PreparedStatement物件

PreparedStatement 可以防止SQL注入，而且效率更高

插入操作，其他對照著都能寫出來，就不再闡述

import com.kuang.utils.JDBCUtils;

import java.sql.Connection;
import java.util.Date;
import java.sql.PreparedStatement;
import java.sql.SQLException;

/**
 * @Author: Lv
 * @Description:
 * @Vision: 1.0
 * @Date: Created in 15:18 2020/7/17
 */
public class PreparedStatment {
    public static void main(String[] args) {

        Connection conn = null;
        PreparedStatement st = null;

        try {
            conn = JDBCUtils.getConnection();
            //區別
            // 使用？佔位符來代替引數
            String sql = "INSERT INTO `student`(`studentId`,`studentName`,`sex`,`gradeid`,`password`,`bith`) VALUES(?,?,?,?,?,?)";
            st = conn.prepareStatement(sql); //預編譯，先不執行
            st.setInt(1,15);
            st.setString(2,"阿豪");
            st.setString(3,"男");
            st.setString(4,"大三");
            st.setString(5,"159753");
            //new Date().getTime()   java的until包下的
            //new java.sql.Date()    資料庫的時間類，要將java型別的轉為SQL型別的
            st.setDate(6,new java.sql.Date(new Date().getTime()));

            int i = st.executeUpdate();
            if (i>0){
                System.out.println("插入成功");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JDBCUtils.release(conn,st,null);
        }
    }
}

PreparedStatement防止注入的本質，把傳遞進來的引數當做字元，假設其中存在轉義字元，比如說 ' 會被直接轉義

10.6 事務

要麼都成功，要麼都失敗

ACID原則

原子性：要麼全部完成，要麼都不完成

一致性：總數不變

隔離性：多個程序互不干擾

永續性：一旦提交不可逆，持久化到資料庫

隔離性的問題：

髒讀：一個事務讀取了另一個沒有提交的事務

不可重複讀：在同一個事務內，重複讀取表中的資料，表資料發生了改變

虛度（幻讀）：在一個事務內，讀取到了別人插入的資料，導致前後讀出來的結果不一致

程式碼實現

1、開啟事務conn.setAutoCommit(false);

2、一組業務執行完畢，提交事務

3、可以在catch語句中顯式定義回滾語句，不定義預設失敗也會回滾

10.7 資料庫連線池

資料庫連線--->執行完畢--->釋放

連線--->釋放十分浪費資源

package com.kuang.c3p0;

import com.mchange.v2.c3p0.ComboPooledDataSource;

import java.sql.*;

/**
 * @Author: Lv
 * @Description:
 * @Vision: 1.0
 * @Date: Created in 17:39 2020/7/17
 */
public class c3p0_TestUtils {

    private static ComboPooledDataSource dateSource = null;

    static {
        try {
            //獲取連線
            dateSource = new ComboPooledDataSource("MySQL");
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
    //獲取連線
    public static Connection getConnection() throws SQLException {
        return dateSource.getConnection();
    }

    //釋放連線資源
    public static void release(Connection conn, Statement st, ResultSet rs){
        if(rs!=null){
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(st!=null){
            try {
                st.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn!=null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}