Mysql数据库详解(看B站狂神mysql记得课后笔记)

Mysql数据库入门详解

数据库的分类

关系型数据库(SQL)

  • MySQL,Oracle,Sql Server ,DB2,SQLlite
  • 通过表和表之间,行和列之间的关系进行数据的储存,学员信息表,考勤表

非关系型数据库(No SQL)

  • Redis,MongDB
  • 非关系型数据库,对象储存,通过对象的自身的属性来决定

DBMS(数据库管理系统)

  • 数据库的管理软件,科学有效的管理我们的数据,维护和获取数据;

  • MySQL,数据管理系统

    使用数据库管理工具创建一个数据库

    数据库字符集要选utf8mb4才是真的utf-8

Mysql数据库详解(看B站狂神mysql记得课后笔记)_第1张图片

连接数据库

在dos里面命令行连接,连接前确定已配置好环境变量

Mysql数据库详解(看B站狂神mysql记得课后笔记)_第2张图片

mysql -uroot -p123456 --(密码)

show databases; --查询所有数据库

use school --切换数据库use 数据库名

show tables; --查看所有的表

describe student; --显示数据库中所有的表的信息 

exit; --退出连接

--单行注释
/**
多行注释
*/

数据库xxx语言 CRUD增删改查

  • DDL 数据库定义语言
  • DML 数据库操作语言
  • DQL 数据库查询语言
  • DCL 数据库控制语言

操作数据库

操作数据库>操作数据库中的表>操作数据库中表的数据

1.创建数据库

CREATE database if not exists westos; --if not exists表示如果不存在

2.删除数据库

drop database if exists westos  --if exists 表示如果存在

3.使用数据库

use school 

数据库数据类型

数值

  • tinyint(十分小的数据 1个字节大小)
  • smallint(较小的数据 2字节)
  • mediumint(中等大小 3字节)
  • int(4字节)
  • bigint(较大的 8字节)
  • float (浮点数,4字节)
  • double(双精度,8字节)
  • decimal (字符串形式的浮点数 金融计算的时候,一般是使用decimal)

字符串

  • char 字符(0-255)
  • varchar 可变字符串(0~65535)对应String
  • tinytext(微型文本 2^8-1)
  • text 文本串 (2^16-1) 大文本

时间日期 java.util.Date

  • date YYYY–MM-DD,日期格式
  • time HH:mm:ss时间格式
  • datetime YYYY–MM-DD HH:mm:ss常用的时间格式
  • timestamp 时间戳 1970.1.1到现在的毫秒数
  • year年份表示

null

  • 没有值
  • 不要使用null值进行运算

数据库的字段属性

Unsigned:

  • 无符号整数
  • 就是只能为正整数

zerofill:

  • 0填充的
  • 不足的位数使用0来填充 int(3) 5 – 005

自增

  • 自动在上一条记录的基础上+1(默认)
  • 通常用来设计唯一的主键 必须是整数类型
  • 可以自定义设计增长值

非空 not null

  • 如果设置为 not null,不给它赋值,就会报错

  • null,如果不填写,默认是null

    创建数据库表

    CREATE TABLE `teachar` (
      `id` int(10) NOT NULL AUTO_INCREMENT,
      `name` varchar(50) COLLATE utf8mb4_bin NOT NULL,
      `password` varchar(50) COLLATE utf8mb4_bin NOT NULL,
      `sex` varchar(2) COLLATE utf8mb4_bin DEFAULT NULL,
      `birthday` datetime DEFAULT NULL,
      `address` varchar(100) COLLATE utf8mb4_bin DEFAULT NULL,
      `email` varchar(50) COLLATE utf8mb4_bin DEFAULT NULL,
      PRIMARY KEY (`id`)
    

) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin




```sql
show create database  school(数据库名) --查看创建数据库的语句

show create table student --查看student数据表查询语句

desc student–显示表的结构


**关于数据库引擎**

- INNODB默认使用
- MYISAM 早些年使用

|              | MYISAM | INNODB                    |
| :----------- | ------ | ------------------------- |
| 事务支持     | 不支持 | 支持                      |
| 数据行锁定   | 不支持 | 支持                      |
| 外键约束     | 不支持 | 支持                      |
| 全文索引     | 支持   | 不支持                    |
| 表空间的大小 | 较小   | 较大约2倍**常规使用操作** |

- MYISAM 节约空间,速度较快

- INNODB 安全性高,事务的处理,多表多用户操作

  

**在物理空间存在的位置**

所有的数据库文件都存在data目录下

本质还是文件的存储

MySQL引擎在物理文件上的区别

- INNODB 在数据库表中只有一个*.frm文件,以及上级目录下的ibdata1文件
- MYISAM 对应的文件
- *.frm 表结构的定义文件
- *.MYD 数据文件(data)
- *.MYI 索引文件(index)



**设置数据库表的字符集编码**

​```sql
charset=utf8   --不设置的话,会是mysql默认编码(不支持中文)

也可以在my.ini中配置默认的编码

character-set-server=utf8

修改删除表

修改

--修改表名
ALTER TABLE teachar RENAME AS teachar1

增加表的字段

--增加表的字段 ALTER TABLE 表名 ADD 字段 列属性
ALTER TABLE teachar1 ADD age INT(11)

--修改表的字段(重命名,修改约束)
ALTER TABLE  teachar1 MODIFY age VARCHAR(11)

--字段重命名
ALTER TABLE teachar1 CHANGE age age1 INT(11)

--删除表的字段
ALTER TABLE teachar1 DROP age1

--删除表
DROP TABLE IF EXISTS teachar1

所有的创建和删除操作尽量加上判断

MySQL数据库管理

外键

CREATE TABLE `student` (
  `id` int(10) NOT NULL AUTO_INCREMENT,
  `name` varchar(50) COLLATE utf8mb4_bin NOT NULL,
  `pwd` varchar(30) COLLATE utf8mb4_bin NOT NULL,
  `sex` varchar(2) COLLATE utf8mb4_bin DEFAULT NULL,
  `birthday` datetime DEFAULT NULL,
  `gradeid` int(10) DEFAULT NULL,
  `address` varchar(100) COLLATE utf8mb4_bin DEFAULT NULL,
  `email` varchar(50) COLLATE utf8mb4_bin DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `grid` (`gradeid`),
  CONSTRAINT `grid` FOREIGN KEY (`gradeid`) REFERENCES `grade` (`gradeid`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin

删除有外键关系的表的时候,必须先删除引用别人的表,再删除被引用的表

物理外键,数据库级别的外键,不建议使用

最佳实践

  • 数据库就是单纯的表,只用来存数据,只有行和列
  • 我们想使用多张表的数据,想使用外键(程序去实现)

DML语言

  • insert
  • update
  • delete

添加


--插入语句(添加)
--INSERT INTO student([字段1,字段2,字段3]) VALUES('值1'),('值2'),('值3')
--由于主键自增我们可以省略(如果不写表的字段,他就会一一匹配)
--一般写插入语句我们一定要数据和字段一一对应

INSERT INTO `grade`(`gradename`) VALUES('萌萌')

INSERT INTO `grade`(`gradename`)
 VALUES('大萌萌'),('无敌萌萌')
 
 
 INSERT INTO `student`(`name`,`pwd`,`sex`)
 VALUES('超萌萌','12234','男'),
       ('超萌a萌','1234','男')
 

注意

1,字段和字段之间使用英文逗号隔开

2,字段是可以省略的但必须和值一一对应,不能少

3, 可以同时插入多条数据,values后面的值,需要使用,隔开即可 values(),()

修改

update 修改谁(条件) set 原来的值=新值

 --修改name字段
UPDATE `student` SET `name`='超级萌萌' WHERE NAME='22'

--不指定条件的情况下,会改动所有表
UPDATE 	`student` SET `name`='帅气的萌萌' 

--修改多个属性
UPDATE `student` SET `name`='超级无敌萌',`pwd`='988',`email`='@qqq.com' WHERE id=1;

--语法:
--update `表名` set `字段名` ='values' where 条件

条件 where 子句 运算符 id等于 大于 小于 在某个区间内修改

操作符返回boolean型

操作符 含义 范围 结果
= 等于 5=6 false
<>或!= 不等于 5!=6 true
>
<
<=
>=
BETWEEN 1 AND 3 在某个范围内 [1,3]
AND 同&&
OR 同||
--通过多个条件
UPDATE `student` SET `name`='超级乖乖' WHERE id<3 AND `name`='好乖乖'

注意

  • 表名 和字段名 尽量都带上· ·以免报错
  • where 筛选条件,如果没有指定,则会修改所有的列
  • value,是一个具体的值,也可以是一个变量
  • 多个设置的属性之间,使用英文逗号隔开

删除

delete命令 语法 delete from 表名 where 条件


--删除数据(避免这样写)
DELETE FROM `student`;

--删除一条数据
DELETE FROM `student` WHERE id=1;

truncate 命令 完全清空一张数据库 表的结构索引约束不会变

--清空student
truncate `student`

delete 和 truncate 区别

  • 相同点:都能删除数据,都不会删除表结构

  • 不同

    • TRUNCATE 重新设置自增列,计数器会归零

    • 不会影响事务

delete删除的问题,重启数据库现象

  • innoDB 自增列会从1开始(存在内存当中,断电即失)
  • MyISAM继续从上一个自增量开始(存在文件中,不会丢失)

DQL查询数据(最重要)

DQL(Data Query language: 数据查询语言)

  • 所有的查询操作都用它 select

  • 简单的查询,复杂的查询它都能做

  • 数据库中最核心的语言

    select完整的语法

    SELECT [ALL | DISTINCT]
    {* | table.* | [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}];
        --  指定查询的记录从哪条至哪条
    

    注意 : [ ] 括号代表可选的 , { }括号代表必选得

-- 创建一个school数据库
create database if not exists `school`;


create database if not exists `school`;
-- 创建一个school数据库
use `school`;-- 创建学生表
drop table if exists `student`;
create table `student`(
`studentno` int(4) not null comment '学号',
`loginpwd` varchar(20) default null,
`studentname` varchar(20) default null comment '学生姓名',
`sex` tinyint(1) default null comment '性别,0或1',
`gradeid` int(11) default null comment '年级编号',
`phone` varchar(50) not null comment '联系电话,允许为空',
`address` varchar(255) not null comment '地址,允许为空',
`borndate` datetime default null comment '出生时间',
`email` varchar (50) not null comment '邮箱账号允许为空',
`identitycard` varchar(18) default null comment '身份证号',
primary key (`studentno`),
unique key `identitycard`(`identitycard`),
key `email` (`email`)
)engine=myisam default charset=utf8;

-- 创建年级表
DROP TABLE IF EXISTS `grade`;
CREATE TABLE `grade`(
	`gradeid` INT(11) NOT NULL AUTO_INCREMENT COMMENT '年级编号',
  `gradename` VARCHAR(50) NOT NULL COMMENT '年级名称',
    PRIMARY KEY (`gradeid`)
) ENGINE=INNODB AUTO_INCREMENT = 6 DEFAULT CHARSET = utf8;


-- 创建科目表
DROP TABLE IF EXISTS `subject`;
CREATE TABLE `subject`(
	`subjectno`INT(11) NOT NULL AUTO_INCREMENT COMMENT '课程编号',
    `subjectname` VARCHAR(50) DEFAULT NULL COMMENT '课程名称',
    `classhour` INT(4) DEFAULT NULL COMMENT '学时',
    `gradeid` INT(4) DEFAULT NULL COMMENT '年级编号',
    PRIMARY KEY (`subjectno`)
)ENGINE = INNODB AUTO_INCREMENT = 19 DEFAULT CHARSET = utf8;


-- 创建成绩表
DROP TABLE IF EXISTS `result`;
CREATE TABLE `result`(
	`studentno` INT(4) NOT NULL COMMENT '学号',
    `subjectno` INT(4) NOT NULL COMMENT '课程编号',
    `examdate` DATETIME NOT NULL COMMENT '考试日期',
    `studentresult` INT (4) NOT NULL COMMENT '考试成绩',
    KEY `subjectno` (`subjectno`)
)ENGINE = INNODB DEFAULT CHARSET = utf8;


-- 插入科目数据
INSERT INTO `subject`(`subjectno`,`subjectname`,`classhour`,`gradeid`)VALUES
(1,'高等数学-1',110,1),
(2,'高等数学-2',110,2),
(3,'高等数学-3',100,3),
(4,'高等数学-4',130,4),
(5,'C语言-1',110,1),
(6,'C语言-2',110,2),
(7,'C语言-3',100,3),
(8,'C语言-4',130,4),
(9,'Java程序设计-1',110,1),
(10,'Java程序设计-2',110,2),
(11,'Java程序设计-3',100,3),
(12,'Java程序设计-4',130,4),
(13,'数据库结构-1',110,1),
(14,'数据库结构-2',110,2),
(15,'数据库结构-3',100,3),
(16,'数据库结构-4',130,4),
(17,'C#基础',130,1);


-- 插入学生数据 其余自行添加 这里只添加了2行
insert into `student` (`studentno`,`loginpwd`,`studentname`,`sex`,`gradeid`,`phone`,`address`,`borndate`,`email`,`identitycard`)
values
(1000,'123456','张伟',0,2,'13800001234','北京朝阳','1980-1-1','[email protected]','123456198001011234'),
(1001,'123456','赵强',1,3,'13800002222','广东深圳','1990-1-1','[email protected]','123456199001011233');

-- 插入成绩数据  这里仅插入了一组,其余自行添加
insert into `result`(`studentno`,`subjectno`,`examdate`,`studentresult`)
values
(1000,1,'2013-11-11 16:00:00',85),
(1000,2,'2013-11-12 16:00:00',70),
(1000,3,'2013-11-11 09:00:00',68),
(1000,4,'2013-11-13 16:00:00',98),
(1000,5,'2013-11-14 16:00:00',58);

-- 插入年级数据
insert into `grade` (`gradeid`,`gradename`) values(1,'大一'),(2,'大二'),(3,'大三'),(4,'大四'),(5,'预科班');

查询指定字段

--查询所有 学生表 
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

语法 selete 字段1,字段2 from 表名

字段名 和表名都可以起别名 (字段名) AS 别名

去重

去重select 查询出来的结果中 重复的数据,重复的数据只显示一条

--查询一下有哪些同学参加了考试成绩
SELECT  `studentno` FROM `result` 
--去除重复数据
SELECT DISTINCT `studentno` FROM `result`

数据库中的表达式 文本值 列 null 函数 表达式

--查询系统版本
SELECT VERSION()

 --用来计算
SELECT 100*5-100 AS 计算

--查询自增的步长
SELECT @@auto_increment_increment

--学员考试成绩 
SELECT  `studentno`,`studentresult`+1 AS `提分后` FROM `result`

select 表达式 from 表

where 条件子句

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

逻辑运算符

运算符 语法 描述
and && a and b a77b 逻辑与
or || a or b a||b 逻辑或
not ! not a !a 逻辑取反
--查询考试成绩在95到100分之间
SELECT `stUdentno` ,`studentresult` FROM `result`
 WHERE `studentresult`>=95 &&`studentresult`<=100



--模糊查询(区间)

SELECT `studentno`,`studentresult` FROM `result`
WHERE `studentresult` BETWEEN 80 AND 100


SELECT `studentno`,`studentresult` FROM `result`
WHERE `studentno`!=1000

SELECT `studentno`,`studentresult` FROM `result`
WHERE NOT `studentno`=1000

模糊查询:比较运算符

运算符 语法 描述
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 SQL匹配 如果a匹配b 则结果为真
in a in(a1,a2,a3…) 假如a在a1 或者a2…其中的一个则返回为真
--模糊查询(区间)

SELECT `studentno`,`studentresult` FROM `result`
WHERE `studentresult` BETWEEN 80 AND 100


SELECT `studentno`,`studentresult` FROM `result`
WHERE `studentno`!=1000

SELECT `studentno`,`studentresult` FROM `result`
WHERE NOT `studentno`=1000


--模糊查询
INSERT INTO `student`(`loginpwd`,`studentname`,`sex`,`gradeid`,`phone`,`address`,`borndate`,`email`,`identitycard`)VALUES
('12345','张无敌猛男','1','12','1998056','爆炸猛男','1980-01-01 00:00:00','@qq.com','1008116')


--like结合 %(代表0到任意个字符) _(一个字符)
SELECT `studentname`,`studentno` FROM `student`
WHERE `studentname` LIKE '张%'


--查询名字后面只有一个字的
SELECT `studentno`,`studentname` FROM `student`
WHERE `studentname` LIKE '%张%'


---IN (具体的一个或者多个值)====
SELECT `studentno`,`studentname` FROM `student`
WHERE `studentno` IN(1001,1002,1003)

--查询是猛男的学生

SELECT `studentno`,`studentname` FROM `student`
WHERE `address` IN('北京朝阳')


--null NOT NULL IS

SELECT `studentno`,`studentname` FROM `student`
WHERE `loginpwd` = '' OR `loginpwd` IS NULL


--查询有出生日期的同学 不为空
SELECT `studentno`,`studentname` FROM `student`
WHERE `borndate` IS NOT NULL

-- 联表模糊查询
SELECT r.studentno,r.studentresult,s.* FROM `student` AS s,`result` AS r
WHERE r.studentno=s.studentno
&& r.studentno=1000
&& s.`studentname` LIKE '%张%'


联表查询

join对比

Mysql数据库详解(看B站狂神mysql记得课后笔记)_第3张图片

七种join理论

Mysql数据库详解(看B站狂神mysql记得课后笔记)_第4张图片

-- === 联表查询 join===================================
SELECT * FROM  `result`,`student`
/*
分析需求 分析查询的字段来自哪些表
确定使用哪种链接查询
确定交叉点(这两个表中哪个数据是相同的)
判断的条件 :学生表中的 studentno=成绩表 studentno
*/
SELECT s.`studentno`,`studentname`,`subjectno`,`studentresult`
 FROM `student` AS s
 INNER JOIN `result` AS r
 WHERE s.`studentno`=r.`studentno`



-- Right join
-- join(连接表名) on(判断条件) 连接查询
-- where 等值查询
SELECT s.`studentno`,`studentname`,`subjectno`,`studentresult`
FROM `student` AS s
RIGHT JOIN `result` AS r
ON s.`studentno` = r.`studentno` 
WHERE s.`studentno` IS NOT NULL



-- left join
SELECT s.`studentno`,`studentname`,`subjectno`,`studentresult`
FROM `student` AS s
LEFT JOIN `result` AS r
ON s.`studentno` = r.`studentno` 



-- 查询学员所属的年级 (学号,学生的姓名,年级名称)
SELECT s.`studentno` AS `学号`,s.`studentname` AS `学生名`,g.`gradename` `年级名`
FROM `student` AS s
INNER JOIN `grade` AS g
ON s.`gradeid`=g.`gradeid`

-- 查询科目所属的年级(科目名称,年级名称 )
SELECT s.`subjectname` AS `科目名称`,g.`gradename` AS `年级名称`
FROM `grade` AS g
INNER JOIN `subject` AS s
ON g.`gradeid`=s.`gradeid`


-- 查询参加了 数据库结构-1 考试的同学 信息 :学号 学生姓名 科目名 分数
SELECT s.`studentno`,s.`studentname`,r.`studentresult`,sub.`subjectname`
FROM `student` AS s
INNER JOIN `result` AS r
ON s.`studentno`=r.`studentno`
INNER JOIN `subject` AS sub
ON s.`gradeid`=sub.`gradeid`
WHERE sub.`subjectname` LIKE '数据库结构%'

/*
 分析查询哪些表 student result subject
 确定使用哪种连接查询
 确定交叉点
 判断条件 学生表中的studentno= studentno
 */
SELECT s.`studentno`,s.`studentname`,su.`subjectname`,r.`studentresult`
FROM `student` AS s
RIGHT JOIN `result` AS r
ON r.`studentno`=s.`studentno`
INNER JOIN `subject` AS su
ON r.`subjectno`=su.`subjectno`
WHERE s.`studentno` IS NOT NULL



-- 我要查询哪些数据 select (字段名)
-- 从哪里查询       from (表名)  (连接方式) join (连接表名) on (连接条件)
-- 假设存在一种多张表查询,慢慢来 先查询两张表慢慢增加
操作 描述
inner join 如果表中至少有一个匹配,就返回行
left join 从左表中返回值 即使右表中没有匹配
right join 从右表中返回所有值 即使 左表中没有匹配
自连接联表查询

自连接建表


CREATE TABLE `school`.`category`( `categoryid` INT(3) NOT NULL COMMENT 'id', `pid` INT(3) NOT NULL COMMENT '父id 没有父则为1', `categoryname` VARCHAR(10) NOT NULL COMMENT '种类名字', PRIMARY KEY (`categoryid`) ) ENGINE=INNODB CHARSET=utf8 COLLATE=utf8_general_ci; 

INSERT INTO `school`.`category` (`categoryid`, `pid`, `categoryname`) VALUES ('2', '1', '信息技术');
insert into `school`.`CATEGOrY` (`categoryid`, `pid`, `categoryname`) values ('3', '1', '软件开发');
insert into `school`.`category` (`categoryid`, `PId`, `categoryname`) values ('5', '1', '美术设计');
insert iNTO `School`.`category` (`categoryid`, `pid`, `categorynamE`) VAlUES ('4', '3', '数据库'); 
insert into `school`.`category` (`CATEgoryid`, `pid`, `categoryname`) values ('8', '2', '办公信息');
insert into `school`.`category` (`categoryid`, `pid`, `CAtegoryname`) values ('6', '3', 'web开发'); 
inserT INTO `SCHool`.`category` (`categoryid`, `pid`, `categoryname`) valueS ('7', '5', 'ps技术');

自连接:自己的表和自己的表链接,核心:一张表拆为两张一样的表即可

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

子类

pid categoryid categoryname
3 4 数据库
2 8 办公信息
3 6 web开发
5 7 美术设计

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

父类 子类
信息技术 办公信息
软件开发 数据库
软件开发 web开发
美术设计 ps技术

查询父子信息

-- 查询父子信息
SELECT a.`categoryname` AS `父栏目`,b.`categoryname` AS `子栏目` 
FROM `category` AS a,`category` AS b
WHERE a.`categoryid`=b.`pid`

分页和排序

--  ==================排序 order by 分页 limit ==============
-- 排序 升序 asc 降序 desc
-- 查询的结果根据 成绩降序 排列

--降序
SELECT s.`studentno`,s.`studentname`,r.`studentresult`,sub.`subjectname`
FROM `student` AS s
INNER JOIN `result` AS r
ON s.`studentno`=r.`studentno`
INNER JOIN `subject` AS sub
ON s.`gradeid`=sub.`gradeid`
WHERE sub.`subjectname` LIKE '数据库结构%'
ORDER BY r.`studentresult` DESC

分页

-- 分页,每页只显示五条数据
-- limit(起始位置,最大数量)
-- (当前页-1) *页面大小 =起始位置 (n-1) *pagesize
-- limmit 0,5
-- limmit 5,5
-- limmit 10,5
SELECT s.`studentno`,s.`studentname`,r.`studentresult`,sub.`subjectname`
FROM `student` AS s
INNER JOIN `result` AS r
ON s.`studentno`=r.`studentno`
INNER JOIN `subject` AS sub
ON s.`gradeid`=sub.`gradeid`
WHERE sub.`subjectname` LIKE '数据库结构%'
ORDER BY r.`studentresult` ASC
LIMIT 0,5  


-- 查询 java课程 成绩排名前十的学生 ,并且分数要大于80 的学生信息(学号,姓名,课程名称)
SELECT sub.`subjectname` AS `课程名称`,s.`studentno` AS `学号`,s.`studentname` AS `学生名称`,r.`studentresult` AS `分数`
FROM `student` AS s
INNER JOIN `subject` AS sub
ON s.`gradeid`=sub.`gradeid`
INNER JOIN `result` AS r
ON s.`studentno`=r.`studentno`
WHERE r.`studentresult`>=80 AND
sub.`subjectname` LIKE 'Java%'
ORDER BY r.`studentresult` DESC
LIMIT 0,10

-- 练习
-- 查询 c语言 前五名成绩 (学号,姓名,分数) 
SELECT s.`studentno`,s.`studentname`,r.`studentresult`,sub.`subjectname`
FROM `student` AS s
INNER JOIN `result` r
ON s.`studentno`=r.`studentno`
INNER JOIN `subject` AS sub
ON r.`subjectno`=sub.`subjectno`
WHERE `subjectname` LIKE '%c语言%'
ORDER BY r.`studentresult` DESC
LIMIT 0,5

语法limt(查询起始下标,页面大小)

分组

-- 查询不同课程的平均分,最高分,最低分
SELECT `subjectname`,AVG(r.`studentresult`) AS 平均分,MAX(r.`studentresult`) AS 最大分,MIN(r.`studentresult`) AS 最低分
FROM `result` AS r
INNER JOIN `subject` AS s
ON r.`subjectno`=s.`subjectno`
GROUP BY s.`subjectno` -- group by 通过什么字段来分组
HAVING 平均分>80  -- having 分组后必须满足的次要条件

子查询

where(这个值是计算出来的)

本质: 在where 语句中嵌套一个子查询语句

MySQL函数

常用函数(假*常用)


--  =============常用函数=========================

-- 数学运算

SELECT ABS(-8)  -- 绝对值
SELECT CEILING(9.4) -- 向上取整
SELECT FLOOR(9.4) -- 向下取整
SELECT RAND() -- 返回0-1 随机数
SELECT SIGN(-10) -- 判断一个数的符号 负数返回-1 整数返回1


-- 字符串函数

SELECT CHAR_LENGTH('劳资是猛男') -- 字符串长度
SELECT CONCAT('劳资','是一个','猛男') -- 拼接字符串
SELECT INSERT('超级无敌猛男',1,2,'劳资是一个') -- 替换字符串,insert("原字符",'开始位置','替换长度','用作替换的字符')
SELECT LOWER('WuDiMengNan') -- 小写字母
SELECT UPPER('WuDiMengNan') -- 大写字母
SELECT INSTR('chaojiwudimengnan','wudi') -- 指定字符第一次出现的位置
SELECT REPLACE('ccccc','c','mengnan') -- 替换指定的字符串
SELECT SUBSTR('超级猛男无人能当',3,30) -- 返回指定的子字符串(源字符串,起始位置,截取长度)
SELECT REVERSE('超级猛男') -- 翻转字符串


-- 时间和日期函数 
SELECT CURRENT_DATE() -- 获取当前日期
SELECT CURDATE() -- 获取当前日期
SELECT NOW() -- 获取当前的时间
SELECT LOCALTIME() -- 本地时间
SELECT SYSDATE() -- 系统时间

SELECT YEAR(NOW()) -- 年
SELECT MONTH(NOW()) -- 月
SELECT DAY(NOW()) -- 日
SELECT HOUR(NOW()) -- 时
SELECT MINUTE(NOW()) -- 分
SELECT SECOND(NOW()) -- 秒

-- 系统
SELECT SYSTEM_USER()
SELECT VERSION()



聚合函数(真*常用)

函数名称 描述
count() 计数
sum() 求和
avg() 平均值
max() 最大值
min() 最小值
-- ================聚合函数====================
-- 统计表中的数 (想查询一个表中有多少个记录就是用count)
SELECT COUNT(`studentname`) FROM `student`; -- count(字段),会忽略所有的null值
SELECT COUNT(*) FROM `student`; -- count(*) 不会忽略null值
SELECT COUNT(1) FROM `result`;-- count(1) 本质 计算行数


SELECT SUM(`studentresult`) AS 总和 FROM `result`;
SELECT AVG(`studentresult`) AS 平均分 FROM `result`
SELECT MAX(`studentresult`) AS 最大分 FROM `result`
SELECT MIN(`studentresult`) AS 最低分 FROM `result`

-- 分组
-- 查询不同课程的平均分,最高分,最低分
SELECT `subjectname`,AVG(r.`studentresult`) AS 平均分,MAX(r.`studentresult`) AS 最大分,MIN(r.`studentresult`) AS 最低分
FROM `result` AS r
INNER JOIN `subject` AS s
ON r.`subjectno`=s.`subjectno`
GROUP BY s.`subjectno` -- group by 通过什么字段来分组
HAVING 平均分>80  -- having 分组后必须满足的次要条件

数据库级别的MD5加密

什么是md5

**MD5由MD4、MD3、MD2改进而来,主要增强算法复杂度和不可逆性。MD5算法因其普遍、稳定、快速的特点,仍广泛应用于普通数据的加密保护领域 **

**md5 破解网站的原理,背后有一个字典,md5 加密后的值 **

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

-- md5 查询
SELECT `pwd` FROM `testmd5`
WHERE `pwd`=MD5('345678')

事务

事务是 一组sql 要么都成功 要么都失败

事务原则 : ACID 原子性 一致性 隔离性 持久性 (脏读 幻读)

原子性(Atomicity)

原子性是指事务是一个不可分割的工作单位,事务中的操作要么都发生,要么都不发生。
一致性(Consistency)

事务前后数据的完整性必须保持一致。
隔离性(Isolation)

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

隔离导致的一些问题

  • 脏读: 指一个事务读取了另一个事务未提交的数据
  • 不可重复读: 在一个事务内读取表中的某一行数据,多次读取结果不同。(这个不一定是错误,只是某些场合不对)
  • **虚读(幻读): **是指在一个事务内读取到了别的事务插入的数据,导致前后读取不一致。
    (一般是行影响,多了一行)

持久性(Durability)

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

--   ===================== 事务 ===============================

-- mysql默认开启事务自动提交的

SET autocommit = 0  -- 关闭自动提交
SET autocommit = 1  -- 开启自动提交

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

COMMIT -- 提交 :持久化(成功)

ROLLBACK -- 回滚:回到原来的样子

 -- 事务结束
 SET autocommit =1 -- 开启自动提交
 
SAVEPOINT 保存点 -- 设置一个事务的保存点

ROLLBACK TO SAVEPOINT 保存点 -- 回滚到保存点

RELEASE 保存点 -- 移除保存点




-- 创建一张测试表
CREATE TABLE `account`(
  `id` INT(7) 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),
       ('B',4000),
       ('C',6000)

-- 模拟转账:事务
SET autocommit =0  -- 关闭自动提交
START TRANSACTION -- 开启一个事务(一组事务)
UPDATE `account` SET `money`=`money`-1000 WHERE `id`=1
UPDATE `account` SET `money`=`money`+1000 WHERE `id`=3

COMMIT;
ROLLBACK;

SET autocommit =1 ;

索引

*ySQL官方对索引的定义为:

索引(index)是帮助MySQL高效获取数据的数据结构(有序)。在数据之外,数据库系统还维护者满足特定查找算法的数据结构,这些数据结构以某种方式引用(指向)数据, 这样就可以在这些数据结构上实现高级查找算法,这种数据结构就是索引

索引的分类

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

  • 主键索引(primary key)
    • 唯一的标识,主键不可重复,只能只有一个列作为索引
  • 唯一索引 (unique key)
    • 避免重复的列出现,唯一索引可以重复,多个列都可以标识唯一索引
  • 常规索引(key / index)
    • 默认的 index key 关键字来设置
  • 全文索引(fulltext)
    • 在特定的数据库引擎下
-- 索引
-- 1 在创建表的时候给字段增加索引
-- 2 创建完毕后,增加索引
-- 显示所有的索引信息
SHOW INDEX FROM `student`

-- 增加一个索引
ALTER TABLE `student` ADD FULLTEXT INDEX `studentname`(`studentname`)


-- explain 分析sql执行的状况
EXPLAIN SELECT * FROM `student` -- 非全文索引

EXPLAIN SELECT * FROM `student` WHERE MATCH(`studentname`) AGAINST('张')

测试索引

-- 插入100万数据.
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`,`eamil`,`phone`,`gender`)VALUES(CONCAT('用户',i),'[email protected]','123456789',FLOOR(RAND()*2));
SET i=i+1;
END WHILE;
RETURN i;
END;

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


SELECT * FROM app_user WHERE `name`='用户100000';

EXPLAIN SELECT * FROM app_user WHERE `name`='用户100000';

-- create index 索引名 on 表
CREATE INDEX id_app_name ON `app_user`(`name`)

在这里插入图片描述
索引在大数据量的时候效率高

索引原则

  • 索引不是越多越好

  • 不要对经常变得数据加索引

  • 小数据量的表不需要加索引

  • 索引一般加在常用来查询的字段上

索引的数据结构

hash 类型的索引

Btree: innoDB 的默认数据结构

权限管理和备份

-- ================权限管理
-- 创建用户
CREATE USER mengnan IDENTIFIED BY '123456'

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

-- 修改密码
SET PASSWORD FOR mengnan = PASSWORD('123')

-- 重命名
RENAME USER mengnan TO menmen

-- 用户授权 all privileges 全部权限 库 表
-- all privileges 除了给别人授权,其他都能干
GRANT ALL PRIVILEGES ON *.* TO menmen


-- 查询权限
SHOW GRANTS FOR menmen  -- 查看指定用户的权限

SHOW GRANTS FOR root@localhost 

-- 撤销权限 
REVOKE ALL PRIVILEGES ON *.* FROM menmen


-- 删除用户
DROP USER menmen

Mysql备份

mysql数据库备份的方式

  • 直接拷贝物理文件

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

    • 在想要导出的表或者库中,右键,选择备份或导出

Mysql数据库详解(看B站狂神mysql记得课后笔记)_第5张图片

  • 使用命令行导出 mysqldump 命令行使用
# mysqldump -h主机名 -u用户名 -p密码 数据库 表名 >物理磁盘路径
mysqldump -hlocalhost -uroot -p123456 school student >D:/1.sql

# mysqldump -h主机名 -u用户名 -p密码 数据库 表名 >物理磁盘路径/文件名 
# 导出多张表
mysqldump -hlocalhost -uroot -p123456 school student result>D:/2.sql

导入数据库

# 先登陆 
mysql -uroot -p123456

#登陆的情况下,切换到指定的数据
#切换到指定数据库
 use school
 
 #导入命令
 source d:/1.sql
 
 #未登录
 mysql -u用户名 -p密码 库民< 备份文件

假设你要备份数据库,防止数据丢失

规范数据库设计


当数据库比较复杂的时候,我们就需要设计了

糟糕的数据库设计

  • 数据冗余,浪费空间
  • 数据库插入和删除都会麻烦,[屏蔽使用物理外键]

良好的数据设计

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

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

  • 分析需求
  • 概要设计:设计关系图E-R图

设计数据库的步骤(个人博客)

  • 收集信息,分析需求

    • 用户表(用户名登陆注销,用户的个人信息,写博客,创建分类)
    • 分类表(文章分类,谁创建的)
    • 文章表(文章的信息)
    • 有链表(友链信息)
    • 自定义表(系统信息,某个关键的字,或者一些字段)
  • 标识实体()

数据库设计的三大范式

三大范式

第一范式(1NF)

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

第二范式(2NF)

前提:满足第一范式

每张表只描述一件事情

第三范式(3NF)

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

规范数据库的设计

规范性和性能的问题

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

  • 考虑商业化的需求和目标 数据库性能更加重要
  • 在规范性能的问题的时候,需要适当的考虑一下 规范性
  • 故意给某表增加一些冗余的字段(从多表查询中变为单表查询)
  • 故意增加一些计算列(从大数据量降低为小数据量的查询)

JDBC(重点)

数据库驱动

Mysql数据库详解(看B站狂神mysql记得课后笔记)_第6张图片

我们的程序会通过数据库驱动 和数据库打交道

jdbc

Java数据库连接,(Java Database Connectivity,简称JDBC)是Java语言中用来规范客户端程序如何来访问数据库的应用程序接口,提供了诸如查询和更新数据库中数据的方法。JDBC也是Sun Microsystems的商标。我们通常说的JDBC是面向关系型数据库的。

对于开发人员只需要使用jdbc即可

Mysql数据库详解(看B站狂神mysql记得课后笔记)_第7张图片

JDBC程序

idea创建一个普通项目

创建册数数据

--  jdbc测试数据

CREATE DATABASE jdbcStudy CHARACTER SET utf8 COLLATE utf8_general_ci;

USE jdbcStudy;

CREATE TABLE `users`(
id INT PRIMARY KEY,
NAME VARCHAR(40),
PASSWORD VARCHAR(40),
email VARCHAR(60),
birthday DATE
);

INSERT INTO `users`(id,NAME,PASSWORD,email,birthday)
VALUES(1,'zhansan','123456','[email protected]','1980-12-04'),
(2,'lisi','123456','[email protected]','1981-12-04'),
(3,'wangwu','123456','[email protected]','1979-12-04')

导入jar包添加到项目中 mysql-connector-java-5.1.49.jar

Mysql数据库详解(看B站狂神mysql记得课后笔记)_第8张图片

测试代码

package com.xxgc;

import java.sql.*;

public class jdbc {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        // 加载驱动
      Class.forName("com.mysql.jdbc.Driver"); //固定写法
        // 用户信息和url
      String url="jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8";
      String usernmae="root";
      String password="123456";
        // 连接成功,数据库对象
        Connection connection = DriverManager.getConnection(url, usernmae, password);

        // 执行sql的对象 去执行sql
        Statement statement = connection.createStatement();

        String sql= "SELECT * FROM `users`";
        //结果集封装了我们全部查询的结果
        ResultSet resultSet = statement.executeQuery(sql);

        while (resultSet.next()){
            System.out.println(resultSet.getObject("id"));
            System.out.println(resultSet.getObject("NAME"));
            System.out.println(resultSet.getObject("PASSWORD"));
            System.out.println(resultSet.getObject("email"));
            System.out.println(resultSet.getObject("birthday"));
        }
        // 释放连接
        resultSet.close();
        statement.close();
        connection.close();


    }
}

步骤总结

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

DriverManager

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

URL

//jdbc:mysql://主机名:端口号/数据库名?参数1&参数2
String url="jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8";


statement 执行sql的对象

        statement.executeQuery();  // 查询
        statement.execute(); //执行任何sql
        statement.executeUpdate(); //更新 插入 删除都用这个,返回一个受影响行数

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

     //和数据库中的类型一一匹配
        resultSet.getObject(); // 不知道列类型的情况下使用
        // 如果知道列的类型就使用指定的类型
        resultSet.getString(); 
        resultSet.getDate();
        resultSet.getInt();
        resultSet.getDouble();

遍历指针

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

释放资源

 // 释放连接 十分耗费资源
        resultSet.close();
        statement.close();
        connection.close();

DRUD代码实现

编写一个jdbc链接数据库的工具类


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

public class jdbcutils {
    private static String driver;
    private static String url;
    private static String username;
    private static String password;

    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");
            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) throws SQLException {
               if(conn!=null) conn.close();

               if(st!=null) st.close();

               if(rs!=null) rs.close();
    }

}

编写一个db.properties配置文件存放链接数据的地址,用户名密码

driver=com.mysql.jdbc.Driver
# 链接时设置编码为utf-8
url=jdbc:mysql://localhost:3306/jdbcstudy?userUnicode=true&characterEncoding=utf8
username=root
password=123456

调用我们编写的工具类,实现插入一条数据

import com.utils.jdbcutils;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;

public class testsql {


    public static void main(String[] args) throws SQLException {
        Connection connection=null;
        Statement statement=null;
        try {
           connection = jdbcutils.getConnection(); //获取数据库链接
           statement = connection.createStatement();//获取sql执行对象
            String sql="INSERT INTO users(`NAME`,`PASSWORD`,`email`,`birthday`) VALUES" +
                    "('三三','1234','[email protected]','2020-06-05')";
            int i = statement.executeUpdate(sql);
            if(i>0) System.out.println("插入成功");

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

        }finally {
              jdbcutils.release(connection,statement,null);
        }
    }
}

编写增删改的方法statement.executeUpdate()

import com.utils.jdbcutils;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;

public class testinsert {


    public static void main(String[] args) throws SQLException {
        Connection connection=null;
        Statement statement=null;
        try {
           connection = jdbcutils.getConnection(); //获取数据库链接
           statement = connection.createStatement();//获取sql执行对象
            String sql="INSERT INTO users(`NAME`,`PASSWORD`,`email`,`birthday`) VALUES" +
                    "('三三','1234','[email protected]','2020-06-05')";
            int i = statement.executeUpdate(sql);
            if(i>0) System.out.println("插入成功");

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

        }finally {
              jdbcutils.release(connection,statement,null);
        }
    }
}

import com.utils.jdbcutils;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;

public class testdelete {


    public static void main(String[] args) throws SQLException {
        Connection connection=null;
        Statement statement=null;
        try {
            connection = jdbcutils.getConnection(); //获取数据库链接
            statement = connection.createStatement();//获取sql执行对象
            String sql="DELETE from `users` WHERE id = 4";
            int i = statement.executeUpdate(sql);
            if(i>0) System.out.println("删除成功");

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

        }finally {
            jdbcutils.release(connection,statement,null);
        }
    }
}

import com.utils.jdbcutils;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;

public class testupdata {


    public static void main(String[] args) throws SQLException {
        Connection connection=null;
        Statement statement=null;
        try {
            connection = jdbcutils.getConnection(); //获取数据库链接
            statement = connection.createStatement();//获取sql执行对象
            String sql="UPDATE `users` SET `NAME`='法外狂徒',`PASSWORD`='4321',`email`='[email protected]' \n" +
                    "WHERE id>1  ";
            int i = statement.executeUpdate(sql);
            if(i>0) System.out.println("修改成功");

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

        }finally {
            jdbcutils.release(connection,statement,null);
        }
    }
}


import com.utils.jdbcutils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class testselect {
    public static void main(String[] args) throws SQLException {
        Connection connection=null;
        Statement statement=null;
        ResultSet rs=null;
        try {
            //获取连接
               connection = jdbcutils.getConnection();
               //获取sql对象
           statement = connection.createStatement();
           //sql
            String sql="select * from users where id=1";
            //查询获取返回集合
            ResultSet query = statement.executeQuery(sql);
            //遍历
            while (query.next()){
                System.out.println(query.getObject("NAME"));
                System.out.println(query.getObject("PASSWORD"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            jdbcutils.release(connection,statement,rs);
        }
    }
}

SQL注入的问题

sql 存在漏洞

import com.utils.jdbcutils;

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

public class SQLinject {
    public static void main(String[] args) throws SQLException {
             login("'' or 1=1","'' or 1=1");
    }
    public static  void login(String username,String password) throws SQLException {
        Connection connection=null;
        Statement statement=null;
        ResultSet rs=null;
        try {
            //SELECT * FROM `users` WHERE `NAME`='' or 1=1 AND `PASSWORD`='' or 1=1 ;
            //获取连接
            connection = jdbcutils.getConnection();
            //获取sql对象
            statement = connection.createStatement();
            //sql
            String sql="SELECT * FROM `users` WHERE `NAME`= "+"'"+username+"'"+" AND `PASSWORD`="+"'"+password+"'";
            //查询获取返回集合
            ResultSet query = statement.executeQuery(sql);
            //遍历
            while (query.next()){
                System.out.println(query.getObject("NAME"));
                System.out.println(query.getObject("PASSWORD"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            jdbcutils.release(connection,statement,rs);
        }
    }
}

PreparedStatement对象

PreparedStatement可以防止SQL注入,更安全

import com.utils.jdbcutils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.Date;


public class testinsert {


    public static void main(String[] args) throws SQLException {
        Connection connection=null;
        PreparedStatement statement=null;
        try {
           connection = jdbcutils.getConnection(); //获取数据库链接
            String sql="INSERT INTO users(`NAME`,`PASSWORD`,`email`,`birthday`) VALUES (?,?,?,?)";
            statement= connection.prepareStatement(sql);
            statement.setObject(1,"张三");
            statement.setObject(2,"123456");
            statement.setObject(3,"[email protected]");
            statement.setObject(4,new java.sql.Date(new Date().getTime()));
            int i = statement.executeUpdate();

            if(i>0) System.out.println("插入成功");

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

        }finally {
              jdbcutils.release(connection,statement,null);
        }
    }
}

import com.utils.jdbcutils;

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


public class testdelete {
    public static void main(String[] args) throws SQLException {
        Connection connection=null;
        PreparedStatement statement=null;
        try {
            connection = jdbcutils.getConnection(); //获取数据库链接
            String sql="DELETE from users WHERE id=?";
            statement= connection.prepareStatement(sql);
            statement.setObject(1,1);

            int i = statement.executeUpdate();

            if(i>0) System.out.println("删除成功");

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

        }finally {
            jdbcutils.release(connection,statement,null);
        }
    }
}

import com.utils.jdbcutils;

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


public class testupdate {
    public static void main(String[] args) throws SQLException {
        Connection connection=null;
        PreparedStatement statement=null;
        try {
            connection = jdbcutils.getConnection(); //获取数据库链接
            String sql="update `users` set `NAME` =?,`PASSWORD`=? WHERE id=?";
            statement= connection.prepareStatement(sql);
            statement.setObject(1,"张三三");
            statement.setObject(2,"123456");
            statement.setObject(3,"2");

            int i = statement.executeUpdate();

            if(i>0) System.out.println("更新成功");

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

        }finally {
            jdbcutils.release(connection,statement,null);
        }
    }
}


import com.utils.jdbcutils;

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

public class testselect {
    public static void main(String[] args) throws SQLException {
        Connection connection=null;
        PreparedStatement statement=null;
        ResultSet rs=null;
        try {
            //获取连接
            connection = jdbcutils.getConnection();
             //sql
            String sql="SELECT * from users WHERE id>?";
            //预编译sql
          statement= connection.prepareStatement(sql);
           //设置参数
          statement.setObject(1,3);
          //执行sql
          rs=statement.executeQuery();
          //遍历结果
          while (rs.next()){
              System.out.println(rs.getObject("NAME"));
          }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            jdbcutils.release(connection,statement,rs);
        }
    }
}

防止sql注入

import com.utils.jdbcutils;

import java.sql.*;

public class LoginTest {
    public static void main(String[] args) throws SQLException {
        login("张三","123456");
    }
    public static  void login(String username,String password) throws SQLException {
        Connection connection=null;
        PreparedStatement statement=null;
        ResultSet rs=null;
        try {
            //SELECT * FROM `users` WHERE `NAME`='' or 1=1 AND `PASSWORD`='' or 1=1 ;
            //获取连接
            connection = jdbcutils.getConnection();
            //获取sql对象
            //PreparedStatement 防止sql注入的本质,把传递进来的参数当做字符
            // 假设其中存在转义字符,比如说' 会被忽略掉
            String sql="SELECT * FROM `users` WHERE `NAME`=? AND `PASSWORD`= ?";
           statement= connection.prepareStatement(sql);
            statement.setObject(1,username);
            statement.setObject(2,password);
            rs=statement.executeQuery();
            //sql

            //查询获取返回集合

            //遍历
            while (rs.next()){
                System.out.println("登陆成功");

            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            jdbcutils.release(connection,statement,rs);
        }
    }
}

使用IDEA 连接mysql

Mysql数据库详解(看B站狂神mysql记得课后笔记)_第9张图片

输入数据库名称,连接名,密码
Mysql数据库详解(看B站狂神mysql记得课后笔记)_第10张图片

连接成功后切换数据库

Mysql数据库详解(看B站狂神mysql记得课后笔记)_第11张图片

在idea中修改的数据必须点绿色箭头的提交才能修改成功

Mysql数据库详解(看B站狂神mysql记得课后笔记)_第12张图片

在console 中选择或者新建一个控制台可以编写sql语句

Mysql数据库详解(看B站狂神mysql记得课后笔记)_第13张图片
如果IDEA连接数据库测试失败

没有导入mysql驱动包导致

Mysql数据库详解(看B站狂神mysql记得课后笔记)_第14张图片
导入驱动包后检查mysql数据源配置版本是否正确

Mysql数据库详解(看B站狂神mysql记得课后笔记)_第15张图片

事务

ACID原则

原子性: 要么全都成功,要么全都失败

一致性: 结果不变,总数一直

隔离性: 多个进程互不干扰

持久性: 一旦提交不可逆,持久化到数据库了

隔离性的问题:

脏读 :一个事务读取了另一个没有提交的事务

不可重复读:在同一个事务内,重复读取表中的数据,表数据发生了改变

虚读(幻读):在一个事务内,读取到了别人插入的数据,导致前后读出来的结果不一致

代码实现

  • 开启事务connection.setAutoCommit(false);
  • 执行业务逻辑
  • 提交事务,持久化到数据库中

import com.utils.jdbcutils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class transaction_01 {
    public static void main(String[] args) throws SQLException {
        Connection connection=null;
        PreparedStatement st=null;
        ResultSet rs=null;
        try {
            connection= jdbcutils.getConnection();
            //关闭数据的自动提交==开启事务
            connection.setAutoCommit(false);

            String sql="UPDATE work set money=money-100 WHERE id=1";
            st=  connection.prepareStatement(sql);
            st.executeUpdate();
//         int i= 1/0; 
            String sql_1="UPDATE work SET money=money+100 WHERE id=2";
            st= connection.prepareStatement(sql_1);
            st.executeUpdate();

            // 业务完毕提交事务
            connection.commit();
            connection.setAutoCommit(true);
            System.out.println("成功");

        } catch (SQLException e) {
            //失败默认回滚
            System.out.println("失败");
            e.printStackTrace();
        }finally {
            jdbcutils.release(connection,st,rs);
        }

    }
}

数据库连接池

数据库连接–执行完毕–释放 十分浪费系统资源

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

最小连接数: 10

最大连接数:20

等待超时:100ms

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

开源数据源实现

DBCP

C3P0

Druid:阿里巴巴

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

DBCP

需要用到的jar包都可以在阿里云仓库找到 commons-dbcp-1.4.jar commons-pool-1.6.jar

DBCP连接池配置

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

#
initialSize=10

#最大连接数量
maxActive=50

#
maxIdle=20

#
minIdle=5

#
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_COMMITTED

从数据源中获取连接

import org.apache.commons.dbcp.BasicDataSourceFactory;
import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

public class jdbcutils_dbcp {

   private static   DataSource source=null;
    static {
        try {

            InputStream in =jdbcutils_dbcp.class.getClassLoader().getResourceAsStream("dbcpconfig.properties");
            Properties properties = new Properties();
            properties.load(in);
          //创建数据源 工厂模式--> 创建对象
             source = BasicDataSourceFactory.createDataSource(properties);


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


    // 获取连接
    public static Connection getConnection() throws SQLException {
        //从数据源中获取连接
        return source.getConnection();
    }
    //释放连接资源
    public static void  release(Connection conn, Statement st, ResultSet rs) throws SQLException {
        if(conn!=null) conn.close();

        if(st!=null) st.close();

        if(rs!=null) rs.close();
    }
}

测试连接和查询

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

public class testdbcp {
    public static void main(String[] args) throws SQLException {
        Connection connection=null;
        PreparedStatement statement=null;
        ResultSet rs=null;
        try {
            //获取连接
            connection = jdbcutils_dbcp.getConnection();
            //sql
            String sql="SELECT * from users WHERE id>?";
            //预编译sql
            statement= connection.prepareStatement(sql);
            //设置参数
            statement.setObject(1,1);
            //执行sql
            rs=statement.executeQuery();
            //遍历结果
            while (rs.next()){
                System.out.println(rs.getObject("NAME"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            jdbcutils_dbcp.release(connection,statement,rs);
        }
    }
}

C3P0

导入jar包 c3p0-0.9.1.2.jar mchange-commons-java-0.2.9.jar


<c3p0-config>
    
    <default-config>
        <property name="driverClass">com.mysql.jdbc.Driverproperty>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbcstudy?userUnicode=true&characterEncoding=utf8&uesSSL=true&serverTimezone=UTCproperty>
        <property name="user">rootproperty>
        <property name="password">123456property>

        <property name="acquiredIncrement">5property>
        <property name="initialPoolSize">10property>
        <property name="minPoolSize">5property>
        <property name="maxPoolSize">20property>

    default-config>

    
    <named-config name="MySQL">
        <property name="driverClass">com.mysql.jdbc.Driverproperty>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbcstudy?userUnicode=true&characterEncoding=utf8&uesSSL=true&serverTimezone=UTCproperty>
        <property name="user">rootproperty>
        <property name="password">123456property>

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

c3p0连接数据库

import com.mchange.v2.c3p0.ComboPooledDataSource;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;


public class jdbcutils_c3p0 {

   private static ComboPooledDataSource source=null;
    static {
        try {
             source= new ComboPooledDataSource("MySQL");
          //创建数据源 工厂模式--> 创建对象
            

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


    // 获取连接
    public static Connection getConnection() throws SQLException {
        //从数据源中获取连接
        return source.getConnection();
    }
    //释放连接资源
    public static void  release(Connection conn, Statement st, ResultSet rs) throws SQLException {
        if(conn!=null) conn.close();

        if(st!=null) st.close();

        if(rs!=null) rs.close();
    }
}

无论使用什么数据源 本质还是一样 ,DataSource 接口不会变

urce ds=new ComboPooledDataSource();"这样写就表示使用的是c3p0的缺省(默认)–>

com.mysql.jdbc.Driver
jdbc:mysql://localhost:3306/jdbcstudy?userUnicode=true&characterEncoding=utf8&uesSSL=true&serverTimezone=UTC
root
123456

    5
    10
    5
    20





    com.mysql.jdbc.Driver
    jdbc:mysql://localhost:3306/jdbcstudy?userUnicode=true&characterEncoding=utf8&uesSSL=true&serverTimezone=UTC
    root
    123456

    5
    10
    5
    20

```

c3p0连接数据库

import com.mchange.v2.c3p0.ComboPooledDataSource;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;


public class jdbcutils_c3p0 {

   private static ComboPooledDataSource source=null;
    static {
        try {
             source= new ComboPooledDataSource("MySQL");
          //创建数据源 工厂模式--> 创建对象
            

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


    // 获取连接
    public static Connection getConnection() throws SQLException {
        //从数据源中获取连接
        return source.getConnection();
    }
    //释放连接资源
    public static void  release(Connection conn, Statement st, ResultSet rs) throws SQLException {
        if(conn!=null) conn.close();

        if(st!=null) st.close();

        if(rs!=null) rs.close();
    }
}

无论使用什么数据源 本质还是一样 ,DataSource 接口不会变

❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀❀完结撒花❀❀❀❀❀❀❀❀❀❀❀❀❀❀

你可能感兴趣的:(mysql,mysql,sql,数据库)