首页 > 数据库 >MySQL数据管理 --- 业务级MySQL

MySQL数据管理 --- 业务级MySQL

时间：2024-07-18 15:51:07浏览次数：23  
标签：-- sql --- 数据管理 conn student MySQL null SELECT

MySQL数据管理 --- 业务级MySQL

外键（了解）

方式一：在创建表的时候，增加约束（麻烦，比较复杂）

DROP TABLE IF EXISTS `grade`;
CREATE TABLE IF NOT EXISTS `grade`(
  `gradeid` INT(5) NOT NULL ,
  `gradename` VARCHAR(20) NOT NULL,
  PRIMARY KEY(`gradeid`)
)ENGINE=INNODB DEFAULT CHARSET=utf8;
-- 学生表的gradeid字段 要去引用年级表的 gradeid
-- 定义外键key
-- 给这个外键添加约束（执行引用） references 引用
DROP TABLE IF EXISTS `student`;
CREATE TABLE IF NOT EXISTS `student`(
  `id` INT(5) NOT NULL AUTO_INCREMENT COMMENT '学号',
  `name` VARCHAR(20) NOT NULL DEFAULT '大傻春' COMMENT '姓名',
  `pwd` VARCHAR(20)  NOT NULL DEFAULT '123456' COMMENT '密码',
  `sex` VARCHAR(2)  NOT NULL DEFAULT '男' COMMENT '性别',
  `birthday` DATETIME  NOT NULL DEFAULT '1997-7-10' COMMENT '生日',
  `address` VARCHAR(50)  NOT NULL DEFAULT '桂林' COMMENT '地址',
  `email` VARCHAR(30)  NOT NULL DEFAULT 'xxx@outlook.com' COMMENT '邮箱',
  `gradeid` INT(5) NOT NULL,
  PRIMARY KEY(`id`),
  KEY `FK_gradeid`(`gradeid`),
  CONSTRAINT `FK_gradeid` FOREIGN KEY(`gradeid`) REFERENCES `grade`(`gradeid`)
)ENGINE=INNODB DEFAULT CHARSET=utf8;

删除有外键关系的表时，必须要先删除引用别人的表（从表），再删除被引用的表（主表）

方式二： 创建表成功后，添加外键约束

DROP TABLE IF EXISTS `grade`;
CREATE TABLE IF NOT EXISTS `grade`(
  `gradeid` INT(5) NOT NULL ,
  `gradename` VARCHAR(20) NOT NULL,
  PRIMARY KEY(`gradeid`)
)ENGINE=INNODB DEFAULT CHARSET=utf8;
-- 学生表的gradeid字段 要去引用年级表的 gradeid
-- 定义外键key
-- 给这个外键添加约束（执行引用） references 引用
DROP TABLE IF EXISTS `student`;
CREATE TABLE IF NOT EXISTS `student`(
  `id` INT(5) NOT NULL AUTO_INCREMENT COMMENT '学号',
  `name` VARCHAR(20) NOT NULL DEFAULT '大傻春' COMMENT '姓名',
  `pwd` VARCHAR(20)  NOT NULL DEFAULT '123456' COMMENT '密码',
  `sex` VARCHAR(2)  NOT NULL DEFAULT '男' COMMENT '性别',
  `birthday` DATETIME  NOT NULL DEFAULT '1997-7-10' COMMENT '生日',
  `address` VARCHAR(50)  NOT NULL DEFAULT '桂林' COMMENT '地址',
  `email` VARCHAR(30)  NOT NULL DEFAULT 'xxx@outlook.com' COMMENT '邮箱',
  `gradeid` INT(5) NOT NULL,
  PRIMARY KEY(`id`)
)ENGINE=INNODB DEFAULT CHARSET=utf8;
-- 创建表的时候没有外键关系
ALTER TABLE `student`
ADD CONSTRAINT `FK_gradeid` FOREIGN KEY(`gradeid`) REFERENCES `grade`(`gradeid`);
-- ALTER TABLE 表 ADD CONSTRAINT 约束名 REFERENCES 哪个表(哪个字段)

以上操作都是物理外键，数据库级别的外键，不建议使用（避免数据库过多造成困扰，了解即可）

最佳实践：

  • 数据库就是单纯的表，只用来存数据，是由行（数据）和列（字段）
  • 想使用多张表的数据，想使用外键（程序去实现）

DML语言

数据库意义：数据存储，数据管理

DML语言：数据操作语言

  • insert
  • update
  • delete

添加

-- 插入语句（添加）
-- 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`,`pwd`,`sex`)VALUES('张三','AAAAAA','男'),('李四','bbbbbb','男'),('林北','AAAbbb','男')

语法：insert into 表名 ([字段名1，字段2，字段3])values('值1'),('值2'),('值3'),(......)

注意事项：

  • 字段和字段之间使用 英文逗号 隔开
  • 字段可以省略，但是后面的值必须 一一对应，不能少
  • 可以同时插入多条数据，VALUES后面的值，需要使用, 隔开 (),()

修改

update 修改谁 （条件）set 原来的值 = 新的值

-- 修改学生名字，带条件
UPDATE `student` SET `name` = '天蓬' WHERE id = 1;
-- 不指定条件的情况下，会改动所有表
UPDATE `student` SET `name` = '八戒';
-- 修改多个属性，逗号隔开
UPDATE `student` SET `name` = '悟空',`email` = '123312@QQ.COM' WHERE id = 1;

-- 语法：
-- UPDATE 表名 SET colnum_name = value,[colnum_name = value,...] WHERE [条件]

条件：where子句 运算符 id 等于某个值，大于某个值，在某个区间

操作符会返回布尔值

操作符 含义 范围 结果
= 等于 5=6 false
<>或!= 不等于 5<>6 true
>
<
<=
>=
between ... and ... 在某个范围内 [2,5]
and 我和你&& 5>1 and 1>2 false
or 我或你|| 5>1 or 1>2 true 
-- 通过多个条件定位数据
UPDATE `student` SET `name` = '悟空' WHERE `name` = '八戒' AND sex='男'

语法：UPDATE 表名 SET colnum_name = value,[colnum_name = value,...] WHERE [条件]

注意：

  • colnum_name 是数据库的列，尽量带上``
  • 条件，筛选的条件，如果没有指定，会修改所有的列
  • value，是一个具体的值，也可以是一个变量
  • 多个设置的属性之间，使用英文逗号隔开
UPDATE `student` SET `birthday` = CURRENT_TIME WHERE `name` = '悟空'

删除

delete 命令

语法：delete from 表名 [where 条件]

-- 删除数据（避免这样写，会全部删除）
DELETE FROM `student`

-- 删除指定数据
DELETE FROM `student` WHERE id = 1

TRUNCATE 命令

作用：完全清空一个数据库表，表的结构和索引约束不会变

-- 清空studen表
TRUNCATE `student`

DELETE 和 TRUNCATE 的区别

  • 相同点：都能删除数据，都不会删除表结构
  • 不同：
    • TRUNCATE 重新设置 自增列 计数器会归零
    • TRUNCATE 不会影响事务

了解即可：DELETE删除的问题 重启数据库，现象

  • InnoDB 自增列会从1开始（自增量存储在内存中）
  • MyISAM 继续从上一个自增量开始（自增量存在文件中，不会丢失）

DQL 查询数据（最重点）

DQL

（Data Query LANGUAGE：数据查询语言）

  • 所有的查询操作都用它 select
  • 简单的查询、复杂的查询都能做
  • 数据库中最核心的语言，最重要的语句
  • 使用频率最高的语句

Select完整语法：

SELECT [ALL | DISTINCT]
{*  |  table.*  |  [table.field1[as alist1][,table.field2[as alist2]][,...]]}
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}];-- 指定查询的记录从哪条到哪条

注意：[]括号表示可选的，{}括号表示必选的

指定查询字段

-- 查询全部的学生
SELECT * FROM student

-- 查询指定字段
SELECT `studentno` ,`studentname` FROM student

-- 别名，给结果起个名字 AS 可以给字段和表起别名
SELECT `studentno` as 学号,`studentname` AS 学生姓名 FROM student as s

-- 函数 concat(a,b)
SELECT CONCAT('姓名：',studentname)as 新名字 from student

语法：SELECT 字段,... FROM 表

有的时候，列名字不是那么见名知意，我们起别名 AS |字段名 as 别名 |表名 as 别名

去重

作用：去除SELECT查询出来的结果中重复的数据，重复的数据只显示一条

--查询一下有哪些同学参加了考试，成绩
SELECT * FROM result -- 查询全部的考试成绩
SELECT `studentno` FROM result --查询有哪些同学参加了考试
-- 去重
SELECT DISTINCT`studentno` FROM result

数据库的列（表达式）

SELECT VERSION() -- 查询系统版本（函数）
SELECT 100*3-1 AS 计算结果 -- 用来计算（表达式）
SELECT @@auto_increment_increment --查询自增的步长（变量）

-- 学生考试成绩 + 1 分 查看
SELECT `studentno`,`studentresult` +1 AS '提分后' FROM result

数据库中的表达式：文本值，列，Null，函数，计算表达式，系统变量，......

select 表达式 from 表

WHERE条件子句

作用：检索数据中符合条件的值

逻辑运算符

运算符 语法 描述
and && a and b a && b
or || a or b a||b
Not ！

尽量使用英文

-- 查询成绩在95-100分之间的
SELECT STUDENTNO,STUDENTRESULT FROM RESULT
-- AND
SELECT STUDENTNO,STUDENTRESULT FROM RESULT WHERE STUDENTRESULT >=95 AND STUDENTRESULT <=100
-- &&
SELECT STUDENTNO,STUDENTRESULT FROM RESULT WHERE STUDENTRESULT >=95 && STUDENTRESULT <=100
-- 模糊查询（区间）BETWEEN
SELECT STUDENTNO,STUDENTRESULT FROM RESULT WHERE STUDENTRESULT BETWEEN 95 AND 100 OR STUDENTRESULT BETWEEN 80 AND 90

-- 除了1000号学生以为的同学的成绩
-- !=
SELECT STUDENTNO,STUDENTRESULT FROM RESULT WHERE STUDENTNO != 1000 and STUDENTNO != 1001
-- NOT
SELECT STUDENTNO,STUDENTRESULT FROM RESULT WHERE NOT STUDENTNO = 1000 AND NOT STUDENTNO = 1001

模糊查询：比较运算符

运算符 语法 描述
IS NULL a is null 如果操作符为NULL，结果为真
IS NOT NULL a is not null 如果操作符不为NULL，结果为真
BETWEEN a between b and c 若a在b和之间，结果为真
LIKE a like b SQL匹配，如果a匹配b，结果为真
In a in (a1,a2,a3,...) 假设a在a1，a2....其中的某一个值中，结果为真 
-- 查询姓刘的同学
-- like结合 % （代表0到任意个字符）_（一个字符）
SELECT studentNO,studentNAME FROM student WHERE studentNAME LIKE '刘%';
-- 查询姓刘的同学，名字后面一个字
SELECT studentNO,studentNAME FROM student WHERE studentNAME LIKE '刘_';
-- 查询姓刘的同学，名字后面两个个字
SELECT studentNO,studentNAME FROM student WHERE studentNAME LIKE '刘__';
-- 查询名字中间有嘉字的同学
SELECT studentNO,studentNAME FROM student WHERE studentNAME LIKE '%嘉%';

-- =====in=====
-- 查询 1001，1002，1003号学员
SELECT studentNO,studentNAME FROM student WHERE studentNO IN (1001,1002,1003)

-- 查询在北京的学生
SELECT studentNO,studentNAME FROM student WHERE ADDRESS IN ('北京')


--====null not null=====
-- 查询地址为空的学生
SELECT studentNO,studentNAME FROM student WHERE ADDRESS = '' OR ADDRESS IS NULL;
-- 查询有生日的同学 不为空
SELECT studentNO,studentNAME FROM student WHERE BORNDATE != '' OR BORNDATE IS NOT NULL;

联表查询

JOIN 对比

image-20240712223301285

img

-- ======联表查询======
SELECT * FROM student
SELECT * FROM RESULT
/* 思路
1. 分析需求，分析查询的字段来自哪些表，（连接查询）
2. 确定使用哪种连接查询？ 7种
确定交叉点（这两个表中哪个数据是相同的）
判断的条件：学生表中国 studentno = 成绩表 studentno*/
SELECT S.studentNO,studentNAME,SUBJECTNO,studentRESULT 
FROM student AS S
INNER JOIN RESULT AS R
WHERE S.studentNO = R.studentno

-- Right Join
SELECT S.studentNO,studentNAME,SUBJECTNO,studentRESULT 
FROM student AS S
RIGHT JOIN RESULT AS R
ON S.studentNO = R.studentno


-- LEFT Join
SELECT S.studentNO,studentNAME,SUBJECTNO,studentRESULT 
FROM student AS S
LEFT JOIN RESULT AS R
ON S.studentNO = R.studentno
操作 描述
INNER JOIN 如果表中至少有一个匹配，就返回行
RIGHT JOIN 会从右表中返回所有的值，即使右表中没有匹配
LEFT JOIN 会从左表中返回所有的值，即使左表中没有匹配 
-- 思考题（查询参加了考试的同学信息：学号、姓名、科目名、分数）
/* 思路
1. 分析需求，分析查询的字段来自哪些表，student\result\subject （连接查询）
2. 确定使用哪种连接查询？ 7种
确定交叉点（这两个表中哪个数据是相同的）
判断的条件：学生表中 studentno = 成绩表 studentno
*/
SELECT s.studentNO,studentNAME,subjectname,studentresult
FROM student AS S
RIGHT JOIN result AS R
ON S.studentno = R.studentno
INNER JOIN `subject` AS sub
ON R.subjectno = sub.subjectno

-- 要查询哪些数据 select ....
-- 从哪几个表中查  from 表  xxx Join 连接的表 on 交叉条件
-- 假设存在一种多张表查询，慢慢来，先查询两张表，然后再慢慢增加

-- From a left join b 主体为 a 表
-- From a RIGHT JOIN b 主体为 b 表

自连接(了解)

自己的表和自己的表连接，核心：一张表拆为两张一样的表即可

image-20240713145201434

父类：

categoryid categoryName
2 信息技术
3 软件开发
5 美术设计

子类：

pid categoryid categoryName
3 4 数据库
2 8 办公信息
3 6 web开发
5 7 ps技术

操作：查询父类对应的子类关系

父类 子类
信息技术 办公信息
软件开发 数据库
软件开发 web开发
美术设计 ps技术 
-- 查询父子信息
SELECT C1.categoryName AS '父类' , C2.categoryName AS '子类'
FROM category AS C1 , category AS C2
WHERE C1.categoryid = C2.pid

分页和排序

排序

-- 分页 limit  排序 order by 
-- 排序：升序 ASC  降序 DESC
-- order by 通过哪个字段排序，怎么排
-- 查询的结果按照 成绩降序排序
SELECT s.studentno,studentname,subjectname,studentresult
FROM student AS s
INNER JOIN result AS r
ON s.studentno = r.studentno
INNER JOIN subject AS sub
ON r.subjectNO = sub.subjectNO
WHERE subjectNAME = '高等数学-1'
ORDER BY studentresult DESC

分页

-- 分页，每页显示五条数据
-- 语法：limit 起始值，页面大小
-- limit 0,5  0-5
-- limit 6,5  6-11
-- limit 1,5  1-6

SELECT s.studentno,studentname,subjectname,studentresult
FROM student AS s
INNER JOIN result AS r
ON s.studentno = r.studentno
INNER JOIN subject AS sub
ON r.subjectNO = sub.subjectNO
WHERE subjectNAME = '高等数学-1'
ORDER BY studentresult DESC
LIMIT 0,5

-- 第一页 limit 0,5  （1-1）*5
-- 第二页 limit 0,5  （2-1）*5
-- 第三页 limit 0,5  （3-1）*5
-- 第N页  limit 0,5  （n-1）* pageSize
-- [pageSize 页面大小]
-- [(n-1)* pageSize 起始值]
-- [n：当前页]
-- [数据总数/页面大小 = 总页数]

语法：limit(查询起始下标,pageSize)

子查询

where（这个值是计算出来的）

本质：在where语句中嵌套一个where语句

-- 连表查询
-- 查询课程为 高等数学-2 且 分数不下于 80 的同学的学号和姓名  
SELECT S.studentno,studentname 
FROM student AS S
INNER JOIN result AS R
ON R.studentno = S.studentno
INNER JOIN subject AS sub
ON R.subjectno = sub.subjectno
WHERE subjectname = '高等数学-2' AND studentresult >= 80

-- 子查询
-- 分数不小于80分的学生的学号和姓名
SELECT DISTINCT S.studentno,studentname 
FROM student AS S
INNER JOIN result AS R
ON R.studentno = S.studentno
WHERE studentresult >= 80

-- 在这个基础上增加一个科目 高等数学-2
-- 查询高等数学-2 的编号
SELECT DISTINCT S.studentno,studentname 
FROM student AS S
INNER JOIN result AS R
ON R.studentno = S.studentno
WHERE studentresult >= 80 AND subjectno = (
    SELECT subjectno FROM subject
    WHERE subjectname = '高等数学-2'
)
-- 再改造
SELECT studentno,studentname FROM student WHERE studentno IN (
  SELECT studentno FROM result WHERE studentresult >= 80 AND
  subjectno = (
    SELECT subjectno FROM subject 
    WHERE subjectname = '高等数学-2'
  )
)

分组和过滤

-- 查询不同课程的平均分、最高分、最低分、平均分大于80
-- 核心：根据不同的课程分组
SELECT subjectname,AVG(studentresult) AS 平均分,MAX(studentresult),MIN(studentresult) FROM result r
INNER JOIN subject sub ON r.subjectno = sub.subjectno
GROUP BY r.subjectno -- 通过什么字段分组
HAVING 平均分 > 80

select小结

MySQL函数

常用函数

SELECT NOW()
SELECT CURDATE()

聚合函数

函数名称 描述
COUNT() 计数
SUM() 求和
AVG() 平均值
MAX() 最大值
MIN() 最小值
...... 
-- 聚合函数
-- 都能统计 表中的数据(想查询一个表中有多少记录，使用count)
SELECT COUNT(borndate) FROM student -- count(字段)，会忽略所有的null值
SELECT COUNT(*) FROM student -- count(*)，不会忽略null值， 本质 计算行数
SELECT COUNT(1) FROM student -- count(1)，不会忽略null值， 本质 计算行数

SELECT SUM(studentresult) AS TOTAL FROM result
SELECT AVG(studentresult) AS TOTAL FROM result
SELECT MAX(studentresult) AS TOTAL FROM result
SELECT MIN(studentresult) AS TOTAL FROM result

数据库级别的MD5加密（拓展）

什么是MD5？

主要增强算法复杂性和不可逆性

MD5不可逆，具体的值的md5是一样的

MD5破解网站的原理，背后有一个字典，MD5加密后的值，加密前的值

--  测试MD5
DROP TABLE IF EXISTS `testmd5`
CREATE TABLE IF NOT EXISTS `testmd5`(
  `id` INT(4) NOT NULL,
  `name` VARCHAR(20) NOT NULL,
  `pwd` VARCHAR(100) NOT NULL,
  PRIMARY KEY(`id`)
)ENGINE=INNODB DEFAULT CHARSET=utf8

-- 明文密码
INSERT INTO testmd5 VALUES (1,'悟空','a123456'),(2,'悟能','a123456'),(3,'悟净','a123456')

-- 加密
UPDATE testmd5 SET pwd=MD5(pwd) -- 加密全部
UPDATE testmd5 SET pwd=MD5(pwd) WHERE id = 1 -- 加密一个

-- 插入时加密
INSERT INTO testmd5 VALUES (4,'悟空',MD5('a123456'))

-- 如何校验：将用户传递进来的密码，进行md5加密，然后对比加密后的值
SELECT * FROM testmd5 WHERE `name` = '悟空' AND pwd = MD5('a123456')

事务

将一组SQL放在一个批次去执行，要么都成功，要么都失败

事务原则：原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）、持久性（Durability）

原文链接：https://blog.csdn.net/dengjili/article/details/82468576

原子性（Atomicity）
原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。

一致性（Consistency）
事务前后数据的完整性必须保持一致。

隔离性（Isolation）
事务的隔离性是多个用户并发访问数据库时，数据库为每一个用户开启的事务，不能被其他事务的操作数据所干扰，多个并发事务之间要相互隔离。

持久性（Durability）--- 事务提交
持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，不可逆，接下来即使数据库发生故障也不应该对其有任何影响

隔离所导致的问题

脏读：

指一个事务读取了另外一个事务未提交的数据。

不可重复读：

在一个事务内读取表中的某一行数据，多次读取结果不同。（这个不一定是错误，只是某些场合不对）

虚读（幻读）：

是指在一个事务内读取到了别的事务插入的数据，导致前后读取数量总量不一致。

-- mysql 默认开启事务自动提交
SET autocommit = 0 /*关闭*/
SET autocommit = 1 /*开启（默认）*/

-- 手动处理事务
SET autocommit = 0 -- 关闭自动提交

-- 事务开启
START TRANSACTION -- 标记一个事务的开始，从这个之后的sql都在同一个事务内

INSERT xx
INSERT xx

-- 提交： 持久化（成功）
COMMIT
-- 回滚： 回到原来的样子（失败）
ROLLBACK

-- 事务结束
SET autocommit = 1 -- 开启自动提交

-- 了解
SAVEPOINT 保存点名 -- 设置一个事务的保持点
ROLLBACK TO SAVEPOINT 保存点名 -- 回滚到保存点
RELEASE SAVEPOINT -- 撤销保存点

模拟事务：

CREATE DATABASE shop CHARACTER SET utf8 COLLATE utf8_general_ci

USE shop
CREATE TABLE `account`(
  id INT(3) NOT NULL auto_increment,
  name VARCHAR(30) NOT NULL,
  money DECIMAL(9,2) NOT NULL,
  PRIMARY KEY(id)
)ENGINE=innodb DEFAULT CHARSET=utf8


INSERT INTO account(name , money)
VALUES('A',2000.00),('B',3000.00)

-- 模拟转账：事务
SET autocommit = 0; -- 关闭自动提交
START TRANSACTION;

UPDATE account SET money=money - 500 WHERE name = 'A'; -- A 减500
UPDATE account SET money=money + 500 WHERE name = 'B'; -- B 加500

COMMIT; -- 提交事务 被持久化
ROLLBACK; -- 回滚

SET autocommit = 1; -- 恢复默认值

索引

MySQL官方对索引的定义：索引（index）是帮助MySQL高效获取数据的数据结构

提取句子主干，就可以得到索引的本质：索引是数据结构

分类

在一个表中，主键索引只能有一个，唯一索引可以有多个

  • 主键索引（PRIMARY KEY）
    • 唯一的标识，主键不可重复，只能有一个列作为主键
  • 唯一索引（UNIQUE KEY）
    • 避免重复的列出现，唯一索引可以重复，多个列都可以标识为 唯一索引
  • 常规索引（KEY/INDEX）
    • 默认的，index，key 关键字来设置
  • 全文索引（FullText）
    • 在特定的数据库引擎下才有，MyISAM
    • 快速定位数据

基础语法：

-- 索引的使用
-- 1、在成绩表的时候给字段增加索引
-- 2、创建完毕后，增加索引

-- 显示所有的索引信息
SHOW INDEX FROM student

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

-- EXPLAIN  分析sql执行的情况

EXPLAIN SELECT * FROM student; -- 非全文索引
EXPLAIN SELECT * FROM student WHERE MATCH(studentName) AGAINST('刘');

测试索引

CREATE TABLE `app_user` (
`id` BIGINT(20) UNSIGNED NOT NULL AUTO_INCREMENT,
`name` VARCHAR(50) DEFAULT '',
`email` VARCHAR(50) NOT NULL,
`phone` VARCHAR(20) DEFAULT '',
`gender` TINYINT(4) UNSIGNED DEFAULT '0',
`password` VARCHAR(100) NOT NULL DEFAULT '',
`age` TINYINT(4) DEFAULT NULL,
`create_time` DATETIME DEFAULT CURRENT_TIMESTAMP,
`update_time` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8

-- 插入100万数据.
SET GLOBAL log_bin_trust_function_creators=1; -- 开启创建函数功能
/*
  第一个语句 delimiter 将 mysql 解释器命令行的结束符由”;” 改成了”$$”，
  让存储过程内的命令遇到”;” 不执行
*/
DELIMITER $$
CREATE FUNCTION mock_data()
RETURNS INT
BEGIN
	DECLARE num INT DEFAULT 1000000;
	DECLARE i INT DEFAULT 0;
	WHILE i<num DO
		INSERT INTO `app_user`(`name`,`email`,`phone`,`gender`)VALUES(CONCAT('用户',i),'19224305@qq.com','123456789',FLOOR(RAND()*2));
		SET i=i+1;
	END WHILE;
	RETURN i;
END;$$

SELECT mock_data()$$ -- 执行此函数 生成一百万条数据


SELECT * FROM app_user WHERE name = '用户9999'

EXPLAIN SELECT * FROM app_user WHERE name = '用户9999'

-- id _ 表名 _ 字段名
-- CREATE INDEX 索引名 ON 表（字段）
CREATE INDEX id_app_user_name ON app_user(`name`)
SELECT * FROM app_user WHERE name = '用户9999'

EXPLAIN SELECT * FROM app_user WHERE name = '用户9999'

索引在小数据量的时候，用处不大，但是在大数据的时候，区别十分明显

索引原则

  • 索引不是越多越好
  • 不要对经常变动的数据加索引
  • 小数据量的表不需要加索引
  • 索引一般加在常用来查询的字段上

索引的数据结构

Hash类型的索引

Btree：InnoDB的默认数据结构

阅读：CodingLabs - MySQL索引背后的数据结构及算法原理

权限管理和数据库备份

用户管理

用户表：mysql.user

本质：对这张表进行增删改查

-- 创建用户  CREATE USER 用户名 IDENTIFIED BY '密码'
CREATE USER kuangshen IDENTIFIED BY '123456'

-- 修改密码 
-- 当前用户
SET PASSWORD = PASSWORD('123456')
-- 指定用户
SET PASSWORD FOR kuangshen = PASSWORD('123456')

-- 重命名
RENAME USER kuangshen TO kuangshen2

-- 用户授权 ALL PRIVILEGES 全部的权限， 库，表
-- ALL PRIVILEGES 除了给别人授权，别的都能干
GRANT ALL PRIVILEGES ON *.* TO kuangshen

-- 查询权限
SHOW GRANTS FOR kuangshen -- 查看指定用户的权限
SHOW GRANTS FOR root@localhost -- 查看root用户权限

-- 撤销权限 REVOKE 哪些权限 ，在哪个库撤销，给谁撤销
REVOKE ALL PRIVILEGES ON *.* FROM kuangshen

-- 删除用户
DROP USER kuangshen

MySQL备份

为什么要备份：

  • 保证重要的数据不丢失
  • 数据转移 A---->B

MySQL备份的方法：

  • 直接拷贝物理文件

  • 在可视化工具中手动导出

    • sql转储

  • 使用命令行导出 mysqldump 命令行使用

     # mysqldump -h 主机 -u 用户名 -p 密码   数据库  表名   > 物理磁盘位置/文件名
 mysqldump -hlocalhost -uroot -p123456 school student >D:/a.sql
 
 # mysqldump -h 主机 -u 用户名 -p 密码   数据库  表1 表2 表3   > 物理磁盘位置/文件名
 mysqldump -hlocalhost -uroot -p123456 school student result >D:/a.sql
 
 # mysqldump -h 主机 -u 用户名 -p 密码   数据库    > 物理磁盘位置/文件名
 mysqldump -hlocalhost -uroot -p123456 school  >D:/a.sql
 
 # 导入
 # 登录的情况下、切换到指定的数据库
 # source 备份文件
 source d:/a.sql
 
 mysql -u用户名 -p密码 库名< 备份文件

数据库的归约，三大范式（规范数据库设计）

为什么要设计

糟糕的数据库设计：

  • 数据冗余，浪费空间
  • 数据库插入和删除都会麻烦、异常【屏蔽使用物理外键】
  • 程序性能差

良好的数据库设计：

  • 节省内存空间
  • 保证数据库的完整性
  • 方便我们开发

软件开发中，关于数据库的设计

  • 分析需求：分析业务和需要处理的数据库的需求
  • 概要设计：设计关系图E-R图

设计数据库的步骤：（个人博客）

  • 收集信息，分析需求
    • 用户表（用户登录注销、用户的个人信息，写博客，创建分类）
    • 分类表（文章分类，谁创建的）
    • 文章表（文章的信息）
    • 友链表（友链信息）
    • 评论表
    • 自定义表（系统信息、某个关键的字、一些主字段） key：value
  • 标识实体（把需求落实到每个字段）
  • 标识实体 之间的关系
    • 写博客：user --> blog
    • 创建分类：user --> category
    • 关注：user --> user

三大范式

为什么需要数据规范化

  • 信息重复
  • 更新异常
  • 插入异常
    • 无法正常显示信息
  • 删除异常
    • 丢失有效信息

三大范式（规范数据库的设计）

第一范式（1NF）

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

第二范式（2NF）

前提：满足第一范式

每张表只描述一件事情

第三范式（3NF）

前提：满足第二范式

第三范式需要确保数据表中的每一列数据都和主键直接相关，而不能间接相关。

规范性 和 性能 的问题

关联查询的表不得超过三张表

  • 考虑商业化的需求和目标，（成本、用户体验）数据库的性能更重要
  • 在规范和性能的问题上，适当考虑一下 规范性
  • 故意给某些表增加一些冗余字段（多表查询变为单表查询）
  • 故意增加一些计算列（从大数据量降低为小数据量的查询：索引）

JDBC（重点）

数据库驱动

JDBC

SUN公司为了简化 开发人员的（对数据库的同一）操作，提供了一个（Java操作数据库的）规范，俗称JDBC

这些规范的实现由具体的厂商去做

对于开发人员来说，我们只需要掌握JDBC接口的操作即可

java.sql

javax.sql

还需要导入一个数据库驱动包

第一个JDBC程序

  • 创建普通项目

  • 导入数据库驱动

  • 编写代码

    package com.gs.lesson;

import com.mysql.jdbc.Driver;

import java.sql.*;

/**
 * @version: java version 1.8
 * @author: 14
 * @description：
 */
public class JdbcFisrstDemo {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        // 1、加载驱动
        Class.forName("com.mysql.jdbc.Driver");
        // 2、用户信息和url
        String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=false";
        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 users";
        ResultSet resultSet = statement.executeQuery(sql);// 返回的结果集,封装了全部的查询结果
        while (resultSet.next()) {
            System.out.println("id:" + resultSet.getObject("id"));
            System.out.println("name:" + resultSet.getObject("name"));
            System.out.println("pwd:" + resultSet.getObject("password"));
            System.out.println("email:" + resultSet.getObject("email"));
            System.out.println("birth:" + resultSet.getObject("birthday"));
        }
        // 6、释放连接
        resultSet.close();
        statement.close();
        connection.close();
    }
}

步骤总结：

  • 加载驱动
  • 连接数据库 DriverManager
  • 获得执行sql的对象 Statement
  • 获得返回的结果集
  • 释放连接

DriverManager

//DriverManager.registerDriver(new Driver());
Class.forName("com.mysql.jdbc.Driver");//固定写法，加载驱动

Connection connection = DriverManager.getConnection(url, username, password);
//connection 代表数据库
//数据库设置自动提交
//事务提交
//事务回滚
connection.setAutoCommit();
connection.commint();
connection.rollback();

URL

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

//mysql --- 3306
//jdbc:mysql://主机地址:端口号/数据库名?参数1&参数2&参数3
//oralce --- 1521
//jdbc:oracle:thin:@localhost:1521:sid

Statement | PrepareStatement 执行sql的对象

String sql = "select * from users" //编写sql

statement.executeQuery();//查询操作 返回ResultSet
statement.execute();//执行任何SQL
statement.executeUpdate();//更新、插入、删除 都是用这个， 返回一个受影响的行数

ResultSet 查询的结果集：封装了所有的查询结果

获得指定的数据类型

resultSet.getObject();// 在不指定列类型的情况下使用
 // 如果知道列类型就使用指定类型
resultSet.getString();
resultSet.getInt();
resultSet.getFloat();
resultSet.getDate();

遍历，指针

resultSet.beforeFirst();//移动到最前面
resultSet.afterLast();//移动到最后面
resultSet.next();//移动到下一个
resultSet.previous();//移动到前一行
resultSet.absolute();//移动到指定行

释放资源

// 6、释放连接
resultSet.close();
statement.close();
connection.close();// 消耗资源，用完关掉

statement对象

代码实现

1、提取工具类

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 stmt, ResultSet rs) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
        if (stmt != null) {
            try {
                stmt.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

2、编写增删改的方法 executeUpdate

public class TestInsert {
    public static void main(String[] args) {
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;
        try {
            conn = JdbcUtils.getConnection(); //获取数据库连接
            stmt = conn.createStatement(); //获得sql的执行对象
            String sql = "INSERT INTO users(ID,NAME,PASSWORD,EMAIL,BIRTHDAY)"+
                    "VALUES(4,'KUANGSHEN','123456','1235563@QQ.COM','2025-1-1')";
            int i  = stmt.executeUpdate(sql);
            if (i > 0){
                System.out.println("插入成功");
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }finally {
            JdbcUtils.release(conn, stmt, rs);
        }
    }
}

public class TestDelete {
    public static void main(String[] args) {
        Connection conn = null;
        Statement stmt = null;

        try {
            conn = JdbcUtils.getConnection();
            stmt = conn.createStatement();
            String sql = "delete from users where id=4";
            int i = stmt.executeUpdate(sql);
            if ( i > 0){
                System.out.println("删除成功");
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }finally {
            JdbcUtils.release(conn,stmt,null);
        }
    }
}

public class TestUpdate {
    public static void main(String[] args) throws SQLException {
        Connection conn = null;
        Statement stmt = null;

        try {
            conn = JdbcUtils.getConnection();
            stmt = conn.createStatement();
            String sql = "UPDATE users SET name= 'kuangshen' ,email = '858728@qq.com' where id = 1";
            int i = stmt.executeUpdate(sql);
            if (i > 0) {
                System.out.println("修改成功");
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }finally {
            JdbcUtils.release(conn, stmt, null);
        }
    }
}

3、查询execuQuery

public class TestSelect {
    public static void main(String[] args) {
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;

        try {
            conn = JdbcUtils.getConnection();
            stmt = conn.createStatement();
            //SQL
            String sql = "select * from users where id = 1";
            rs = stmt.executeQuery(sql);
            while (rs.next()) {
                System.out.println(rs.getString("name"));
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }finally {
            JdbcUtils.release(conn, stmt, rs);
        }
    }
}

SQL注入的问题

sql存在漏洞，会被攻击导致数据泄露 SQL会被拼接 or

public class SQL注入 {
    public static void main(String[] args) {

        login("' or'1=1","' or'1=1");
    }

    public static void login(String username, String password){
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;

        try {
            conn = JdbcUtils.getConnection();
            stmt = conn.createStatement();
            String sql = "select * from users where name = '"+username+"' and password = '"+password+"'";
            rs = stmt.executeQuery(sql);
            while(rs.next()){
                System.out.println(rs.getString("name"));
                System.out.println(rs.getString("password"));
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            JdbcUtils.release(conn, stmt, rs);
        }
    }
}

PreparedStatement

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

1、新增

public class TestInsert {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            conn = JdbcUtils.getConnection(); //获取数据库连接

            //区别
            //使用?占位符 代替参数

            String sql = "INSERT INTO users(ID,NAME,PASSWORD,EMAIL,BIRTHDAY)"+
                    "VALUES(?,?,?,?,?)";
            ps = conn.prepareStatement(sql);//预编译SQL，先写sql，然后不执行

            //手动给参数赋值
            ps.setInt(1,6);
            ps.setString(2,"shisi");
            ps.setString(3,"123456");
            ps.setString(4,"8578482@qq.com");
            //注意点：sql.Date   数据库   java.sql.Date
            //       util.Date   java   new Date().getTime() 获得时间戳
            ps.setDate(5, new java.sql.Date(new Date().getTime()));

            //执行
            int i = ps.executeUpdate();
            if (i > 0) {
                System.out.println("插入成功");
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }finally {
            JdbcUtils.release(conn, ps, rs);
        }
    }
}

2、删除

public class TestDelete {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement ps = null;

        try {
            conn = JdbcUtils.getConnection();

            String sql = "delete from users where id=?";

            ps = conn.prepareStatement(sql);
            ps.setInt(1, 5);
            int i = ps.executeUpdate();
            if ( i > 0){
                System.out.println("删除成功");
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }finally {
            JdbcUtils.release(conn,ps,null);
        }
    }
}

3、更新

public class TestUpdate {
    public static void main(String[] args) throws SQLException {
        Connection conn = null;
        PreparedStatement ps = null;

        try {
            conn = JdbcUtils.getConnection();
            String sql = "UPDATE users SET name=?  where id =?";

            ps = conn.prepareStatement(sql);

            ps.setString(1, "kuangshen");
            ps.setInt(2, 5);

            int i = ps.executeUpdate();
            if (i > 0) {
                System.out.println("修改成功");
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }finally {
            JdbcUtils.release(conn, ps, null);
        }
    }
}

4、查询

public class TestSelect {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;

        try {
            conn = JdbcUtils.getConnection();
            //SQL
            String sql = "select * from users where id =?";

            ps = conn.prepareStatement(sql);
            ps.setInt(1, 6);//传递参数
            rs = ps.executeQuery();
            while (rs.next()) {
                System.out.println(rs.getString("name"));
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }finally {
            JdbcUtils.release(conn, ps, rs);
        }
    }
}

5、防止SQL注入

public class SQL注入 {
    public static void main(String[] args) {

        login("' or'1=1","' or'1=1");
    }

    public static void login(String username, String password){
        Connection conn = null;
        PreparedStatement stmt = null;
        ResultSet rs = null;

        try {
            conn = JdbcUtils.getConnection();
            //PreparedStatement 防止SQL注入的本质，把传递进来的参数当做字符串
            // 假设其中存在转义字符，直接忽略，比如说'
            String sql = "select * from users where name = ? and password = ?";
            stmt = conn.prepareStatement(sql);
            stmt.setString(1, username);
            stmt.setString(2, password);
            rs = stmt.executeQuery();
            while(rs.next()){
                System.out.println(rs.getString("name"));
                System.out.println(rs.getString("password"));
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            JdbcUtils.release(conn, stmt, rs);
        }
    }
}

使用IDEA连接数据库

事务

代码实现

1、关闭自动提交，开启事务conn.setAutoCommit(false);

2、一组事务执行完毕，提交事务

3、可以在catch语句中显式的定义 回滚语句，但默认失败就会回滚

public class 事务 {
    public static void main(String[] args) {
        Connection con = null;
        PreparedStatement ps = null;
        ResultSet rs = null;

        try {
            con = JdbcUtils.getConnection();

            con.setAutoCommit(false);// 关闭自动提交，开启事务

            String sql = "UPDATE account SET money = money - 100 where name = 'A'";
            ps = con.prepareStatement(sql);
            ps.executeUpdate();

            //int i = 1/0; // 让 事务 不能完成

            sql = "UPDATE account SET money = money + 100 where name = 'B'";
            ps = con.prepareStatement(sql);
            ps.executeUpdate();

            con.commit();// 业务完成 提交
        }catch (SQLException e) {
            throw new RuntimeException(e);
        }finally {
            JdbcUtils.release(con, ps, rs);
        }
    }
}

数据库连接池

数据库连接 ---- 执行完毕 ---- 释放

连接 ---- 释放 十分浪费系统资源

池化技术：准备一些预先的资源，过来就连接预先准备好的

----- 开门 ------ 业务员：等待 ------ 服务 ------

若 常用连接数：10个

​ 最小连接数：10个

​ 最大连接数：15个 业务最高承载上限

​ 等待超时：100ms

编写连接池，实现一个接口 DataSource

开源数据源实现

DBCP

C3P0

Druid：阿里巴巴

使用了这些数据库连接池后，在项目开发中就不需要编写连接数据库的代码了

DBCP

需要的jar包

commons-dbcp-1,4.jar commons-pool-1.6.jar

工具类

public class JdbcUtils_DBCP {

    private static DataSource dataSource = null;

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

            //创建数据源 工厂模式  --->创建
            dataSource = BasicDataSourceFactory.createDataSource(properties);

        }catch (Exception e){
            e.printStackTrace();
        }
    }

    //获取连接资源
    public static Connection getConnection() throws SQLException {
        return dataSource.getConnection();//从数据源中获取连接
    }

    //释放连接资源
    public static void release(Connection conn, Statement stmt, ResultSet rs) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
        if (stmt != null) {
            try {
                stmt.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

配置文件

#连接设置
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=false
username=root
password=123456

#<!-- 初始化连接 -->
initialSize=10

#最大连接数量
maxActive=50

#<!-- 最大空闲连接 -->
maxIdle=20

#<!-- 最小空闲连接 -->
minIdle=5

#<!-- 超时等待时间以毫秒为单位 6000毫秒/1000等于60秒 -->
maxWait=60000
#JDBC驱动建立连接时附带的连接属性属性的格式必须为这样：【属性名=property;】
#注意："user" 与 "password" 两个属性会被明确地传递，因此这里不需要包含他们。
connectionProperties=useUnicode=true;characterEncoding=UTF8

#指定由连接池所创建的连接的自动提交（auto-commit）状态。
defaultAutoCommit=true

#driver default 指定由连接池所创建的连接的只读（read-only）状态。
#如果没有设置该值，则“setReadOnly”方法将不被调用。（某些驱动并不支持只读模式，如：Informix）
defaultReadOnly=

#driver default 指定由连接池所创建的连接的事务级别（TransactionIsolation）。
#可用值为下列之一：（详情可见javadoc。）NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE
defaultTransactionIsolation=READ_UNCOMMITTED

C3P0

需要的jar包

c3p0-0.9.5.5.jar 、mchange-commons-java-0.2.19.jar

工具类

public class JdbcUtils_C3P0 {

    private static DataSource dataSource = null;

    static {
        try {
            //创建数据源 工厂模式  --->创建
            dataSource = new ComboPooledDataSource("MySQL");//配置文件写法

        }catch (Exception e){
            e.printStackTrace();
        }
    }

    //获取连接资源
    public static Connection getConnection() throws SQLException {
        return dataSource.getConnection();//从数据源中获取连接
    }

    //释放连接资源
    public static void release(Connection conn, Statement stmt, ResultSet rs) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
        if (stmt != null) {
            try {
                stmt.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

配置文件

<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>
    <!--
c3p0的缺省（默认）配置
如果在代码中"ComboPooledDataSource ds=new ComboPooledDataSource();"这样写就表示使用的是c3p0的缺省（默认）-->
    <default-config>
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbcstudy?userUnicode=true&amp;characterEncoding=utf8&amp;uesSSL=true&amp;serverTimezone=UTC</property>
        <property name="user">root</property>
        <property name="password">123456</property>

        <property name="acquiredIncrement">5</property>
        <property name="initialPoolSize">10</property>
        <property name="minPoolSize">5</property>
        <property name="maxPoolSize">20</property>
    </default-config>

    <!--如果在代码中"ComboPooledDataSource ds=new ComboPooledDataSource("MySQL");"这样写就表示使用的是name是MySQL的配置-->
    <named-config name="MySQL">
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbcstudy?userUnicode=true&amp;characterEncoding=utf8&amp;uesSSL=true&amp;serverTimezone=UTC</property>
        <property name="user">root</property>
        <property name="password">123456</property>

        <property name="acquiredIncrement">5</property>
        <property name="initialPoolSize">10</property>
        <property name="minPoolSize">5</property>
        <property name="maxPoolSize">20</property>
    </named-config>
</c3p0-config>

结论

无论使用什么数据源，本质还是一样的，DataSource接口不会变，方法也不会变

标签：--,sql,---,数据管理,conn,student,MySQL,null,SELECT
From： https://www.cnblogs.com/shisi2001/p/18309735

相关文章

  • mysql入门
    1.mysql下载 https://dev.mysql.com/downloads/mysql/我下载的是这个（两个的区别：上面的是联网安装，下面的是直接下载到本地安装）  2.下载后点击安装，按照指示一直点击下一步就可以安装过程中需要记录自己设置的密码，以及WindowsServiceName，之后连接的时候需要用到。 ......
  • 【web]-php反序列化-复杂1（转）
    转自：PHP反序列化-CSDN博客反序列化漏洞是基于序列化和反序列化的操作，在反序列化——unserialize()时存在用户可控参数，而反序列化会自动调用一些魔术方法，如果魔术方法内存在一些敏感操作例如eval()函数，而且参数是通过反序列化产生的，那么用户就可以通过改变参数来执行敏感操作......
  • 全球1-15级（12,5米）高程terrain和pak切片数据
       Terrain切片是一种分级存储的地形数据，用于地理信息系统（GIS）、虚拟地球、灾害模拟与管理以及环境保护与规划。PAK切片则是一种特定格式的瓦片数据，广泛应用于游戏开发、虚拟现实（VR）和增强现实（AR），以及工程和建筑领域。   本数据集基于全球12.5米DEM数据（http://www.gis......
  • [misc]-压缩包-zip
    题目：拼在一起解下base64就有flag打开附件，发现都是68个小的压缩文件，且是加密的，根据题目提示，考虑crc32碰撞。importzipfileimportstringimportbinasciiimportbase64d=open('rs.zip','wb')b64=''dic=string.ascii_letters+string.digits+'{}_+/='......
  • 君方智能设计平台-数据对象升级框架设计
    1.设计背景    由于文件存储基于流存储，目前处于快速开发阶段，修改对象数据结构很频繁。对象数据结构的修改，会破坏文件的二进制内存结构，版本发布时导致一些已创建的项目文件不能正常打开。目前的解决方案是，先将文件导出为XPE文件，然后再通过XPE文件导入君方智能设计平台。......
  • 3.2-LSTM的代码实现
    文章目录1LSTM结构整理2LSTM的代码实现2.1初始化和前向传播2.2反向传播3TimeLSTM层的实现3.1TimeLSTM层的结构3.2TimeLSTM层的代码实现3.2.1初始化3.2.2前向传播3.2.3反向传播4使用LSTM对语言模型建模4.1初始化4.2前向计算4.3反向传播4.4其他5在PTB数据集上......
  • [米联客-安路飞龙DR1-FPSOC] FPGA基础篇连载-19读写I2C接口EEPROM实验
    软件版本：Anlogic-TD5.9.1-DR1_ES1.1操作系统：WIN1064bit硬件平台：适用安路(Anlogic)FPGA实验平台：米联客-MLK-L1-CZ06-DR1M90G开发板板卡获取平台：https://milianke.tmall.com/登录"米联客"FPGA社区http://www.uisrc.com视频课程、答疑解惑！ 1概述......
  • 如何快速排查线上问题 -copy qf
    排查流程图flowchartTBA-->B-->C-->D-->EsubgraphA[认识问题]A1[收集信息]A2[确认问题]A3[复现问题]A4[影响范围]A1-->A2-->A3-->A4endsubgraphB[诊断/确认问题]B1[检查网络连接]......
  • 链表（3） ----快慢指针，求中间节点
    目录快慢指针算法步骤：为什么有效？使用场景：力扣876题目 方法代码 力扣142题目方法1代码 方法2 思路代码 官网地址：https://www.dhcode.cn/p/t_pc/goods_pc_detail/goods_detail/term_624bd804b3d39_Ac0g7V?fromH5=true&type=3&channel_id=&pro_id=term_62......
  • PlantUML-UML 绘图工具安装、Graphviz安装、本地使用/在线使用、语法、图示案例
    文章目录前言本地安装vscode安装插件下载安装Graphviz配置Graphviz环境变量测试在线使用演示PlantUML语法总结活动图（新语法）时序图类图用例图其他图更多相关内容可查看前言本篇提供两种使用方式分别为在线使用地址1：https://www.planttext.com/在线使用地址2vsco......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99