MySQL

Posted 2021-10-08 明懋的博客

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了MySQL相关的知识，希望对你有一定的参考价值。

mysql

1.初识MySQL

mysql安装

mysql安装方法

sqlyog安装及使用

连接数据库，命令行

mysql -uroot -p123456 --连接数据库

--修改用户密码
update mysql.user set authentication_string=password(\'123456\') where user=\'root\' and Host = \'localhost\'; 
flush privileges; --刷新权限

-- 所有的语句都使用；结尾
show databases; -- 查询所有数据库

use school; --切换数据库

show tables; --查看数据库中所有的表

describe student; --显示表中所有信息

create database school2; -- 创建数据库

exit --退出连接
-- sql本来的注释
/*
多行注释
*/

2.操作数据库

mysql数据库不区分大小写

操作数据库

CREATE DATABASE IF NOT EXISTS school3;--创建数据库
DROP DATABASE IF EXISTS school2;--删除数据库
USE `school`；--切换数据库

SELECT `user` FROM student; --查询表中的字段

SHOW DATABASES;--查看所有的数据库

数据库的列数据类型

数值

整数：

tinyint 1字节
smallint 2字节
mediumint 3字节
int 4字节常用 java int
bigint 8字节

小数：

float 4字节
double 8字节
decimal 字符串形式的浮点数，金融计算使用

字符串

char 0-255 固定长度
varchar 0-65535 可变长字符串常用 java 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进行运算，否则结果为null

数据库的字段属性

Unsigned:

无符号的整数
勾选表示该列不能为负数

Zerofill:

0填充
不足的位数用0填充：例如int（3）5 变成 005

自增：

自动在上一条记录值上+1（默认）
通常用来设置唯一的主键~index，必须是整数类型
可以自定义设置自增的起始值和步长

非空：
null 和 not null

勾选便设置为not null 便必须赋值
不勾选默认为null,可以为空

默认：

设置默认值
例如：sex 默认值男

-- 每一个表都必须存在以下5个字段：
id -- 主键
`version` -- 乐观锁
is_delete -- 伪删除
gmt_create -- 创建时间
gmt_update -- 修改时间

创建数据库表，sql

CREATE TABLE IF NOT EXISTS `student2`(
`id` INT(4) NOT NULL AUTO_INCREMENT COMMENT \'学生id\',
`name` VARCHAR(30) NOT NULL DEFAULT \'匿名\' COMMENT \'学生姓名\',
`pwd` VARCHAR(20) NOT NULL DEFAULT \'123456\' COMMENT \'密码\',
`sex` VARCHAR(2) NOT NULL DEFAULT \'女\' COMMENT \'性别\',
`birthday` DATETIME DEFAULT NULL COMMENT \'出生日期\',
`address` VARCHAR(100) DEFAULT NULL COMMENT \'家庭住址\',
`email` VARCHAR(50) DEFAULT NULL COMMENT \'邮箱\',
PRIMARY KEY(`id`)
)ENGINE=INNODB DEFAULT CHARSET=utf8

常用命令

-- 1.创建数据库的语句
SHOW CREATE DATABASE school; 
CREATE DATABASE `school` /*!40100 DEFAULT CHARACTER SET utf8 */
-- 2.创建表的语句
SHOW CREATE TABLE student1; 
CREATE TABLE `student1` (
  `id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT COMMENT \'学生id\',
  `name` VARCHAR(10) NOT NULL COMMENT \'学生姓名\',
  `sex` CHAR(2) NOT NULL DEFAULT \'男\' COMMENT \'学生性别\',
  PRIMARY KEY (`id`)
) ENGINE=INNODB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8
-- 3.查看表的结构
DESC student;

数据库引擎

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

	MYISAM	INNODB
事务支持	不支持	支持
数据行锁定	不支持	支持
外键约束	不支持	支持
全文索引	支持	不支持
表空间的大小	较小	较大，约为2倍

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

CHARSET=utf8;

不设置的话是mysql默认字符集编码，不支持中文

修改和删除表

修改：

-- 修改表
-- 修改表名
ALTER TABLE `student` RENAME `student0`; 
-- 增加表的字段
ALTER TABLE `student0` ADD `email` VARCHAR(50);
-- 修改表的字段（重命名，修改约束）
ALTER TABLE `student0` MODIFY `age` VARCHAR(5);
ALTER TABLE `student0` CHANGE `age` `age1` INT(10);
-- 删除表的字段
ALTER TABLE `student0` DROP `age1`;

删除：

-- 删除表
DROP TABLE IF EXISTS `student0`;

3.MYSQL的数据管理

外键了解即可

方式一：

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

CREATE TABLE `student0` (
  `id` INT(4) NOT NULL AUTO_INCREMENT COMMENT \'学生id\',
  `name` VARCHAR(30) NOT NULL DEFAULT \'匿名\' COMMENT \'学生姓名\',
  `pwd` VARCHAR(20) NOT NULL DEFAULT \'123456\' COMMENT \'密码\',
  `sex` VARCHAR(2) NOT NULL DEFAULT \'女\' COMMENT \'性别\',
  `gradeid` INT(10) NOT NULL COMMENT \'年级id\',
  `birthday` DATETIME DEFAULT NULL COMMENT \'出生日期\',
  `address` VARCHAR(100) 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

方式二：

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

CREATE TABLE `student0` (
  `id` INT(4) NOT NULL AUTO_INCREMENT COMMENT \'学生id\',
  `name` VARCHAR(30) NOT NULL DEFAULT \'匿名\' COMMENT \'学生姓名\',
  `pwd` VARCHAR(20) NOT NULL DEFAULT \'123456\' COMMENT \'密码\',
  `sex` VARCHAR(2) NOT NULL DEFAULT \'女\' COMMENT \'性别\',
  `gradeid` INT(10) NOT NULL COMMENT \'年级id\',
  `birthday` DATETIME DEFAULT NULL COMMENT \'出生日期\',
  `address` VARCHAR(100) DEFAULT NULL COMMENT \'家庭住址\',
  `email` VARCHAR(50) DEFAULT NULL COMMENT \'邮箱\',
  PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8

ALTER TABLE `student0`
ADD CONSTRAINT `FK_gradeid` FOREIGN KEY (`gradeid`) REFERENCES `grade`(`gradeid`);

DML语言

添加

-- 插入语句，添加
-- insert into 表名(字段1，字段2，字段3,...) values(\'值1\'，\'值2\'，\'值3\',...);
-- 主键自增可以省略
-- 语句太长可以分行写，只在行末加;
INSERT INTO `grade` (`gradename`) VALUES (\'大四\');
INSERT INTO `grade` (`gradename`) VALUES (\'大三\'),(\'大二\');
INSERT INTO `student1`(`name`,`sex`)
VALUES(\'小芳\',\'女\'),(\'Anna\',\'女\');
INSERT INTO `student1` VALUES(\'7\',\'小芳\',\'女\');

修改

-- 修改学员的名字,指定条件
UPDATE `student0` SET `name`=\'mingmao\' WHERE `id`=1;
-- 修改学员的名字,不指定条件,会改动所有数据
UPDATE `student0` SET `name`=\'mingmao\';
-- 修改多个属性
UPDATE `student0` SET `name`=\'mingmao0\',`email`=\'2792178110@qq.com\' WHERE `id`=2;

条件：where子句

操作符	含义	范围	结果
=	等于	5=6	false
<>或!=	不等于	5<>6	true
>	大于
<	小于
>=
<=
between...and...	在某个范围内	between 2 and 5	[2,5]
and		5>1 and 1>2	false
or		5>1 or 1>2	true

-- 通过多个条件定位数据
UPDATE `student0` SET `name`=\'mingmao123\' WHERE `name`=\'mingmao\' AND `sex`=\'女\';

删除

delete命令：

-- 删除指定数据
DELETE FROM `student0` WHERE `id`=1;
-- 完全清空一个数据表的数据，表的结构和索引不变
TRUNCATE `student0`;

4.DQL查询数据

DQL

指定查询字段

CREATE DATABASE IF NOT EXISTS `school`;
-- 创建一个school数据库
USE `school`;
-- 创建年级表
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 \'年级编号\',
    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 \'考试成绩\',
    PRIMARY KEY `subjectno` (`subjectno`)
)ENGINE = INNODB DEFAULT CHARSET = utf8;
-- 创建学生表
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;
-- 插入学生数据 其余自行添加 这里只添加了2行
INSERT INTO `student` (`studentno`,`loginpwd`,`studentname`,`sex`,`gradeid`,`phone`,`address`,`borndate`,`email`,`identitycard`)
VALUES
(1000,123456,\'张伟\',0,2,13800001234,\'北京朝阳\',\'1980-1-1\',\'text123@qq.com\',123456198001011234),
(1001,123456,\'赵强\',1,3,13800002222,\'广东深圳\',\'1990-1-1\',\'text111@qq.com\',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,\'预科班\');
-- 插入科目数据
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);

分段执行，然后出现如下四个表：

-- 查询全部数据
-- 查询全部的学生
SELECT * FROM `student`;
-- 查询全部成绩
SELECT * FROM `result`;

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

-- 使用别名，对查询出的字段和表重命名
SELECT `studentno` AS 学号,`studentname` AS 学生姓名 FROM `student` AS 学生表;

-- 函数
-- 拼接字符串
SELECT CONCAT(\'姓名：\',`studentname`) AS 学生姓名 FROM `student`;

去重

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

数据库的列（表达式）

-- 查询系统版本
SELECT VERSION(); -- 5.7.35-log 函数
-- 用来计算
SELECT 200*3-98 AS \'计算结果\'; -- 502 表达式
-- 查询自增的步长
SELECT @@auto_increment_increment; -- 1 变量

-- 学员考试成绩+10查看
SELECT `studentno`,`studentresult`+10 AS \'提10分后成绩\' FROM `result`;

where条件子句

检索数据中符合条件的值
逻辑运算符：

运算符	语法	描述
and &&	a and b 或者 a&&b	逻辑与
or \|\|	a or b 或者 a\|\|b	逻辑或
not !	not a 或者 !a	逻辑非

-- 查询所有学生的成绩
SELECT `studentno`,`studentresult` FROM `result`;
-- 查询成绩在95-100之间的学生成绩
SELECT `studentno`,`studentresult` FROM `result`
WHERE `studentresult`>=95 AND `studentresult`<=100;
-- 查询成绩在95-100之间的学生成绩,模糊查询
SELECT `studentno`,`studentresult` FROM `result`
WHERE `studentresult` BETWEEN 80 AND 100;
-- 查询除了1000号学生之外的学生的成绩
SELECT `studentno`,`studentresult` FROM `result`
WHERE `studentno`!=1000; -- 写法一
SELECT `studentno`,`studentresult` FROM `result`
WHERE NOT `studentno`=1000; -- 写法二

模糊查询:比较运算符

运算符	语法	描述
is null	a is null	如果a为null，结果为true
is not null	a is not null	如果a不为null，结果为true
between...and...	a between b and c	如果a在b和c之间，结果为true
like	a like b	SQL匹配，如果a匹配到b,结果为true
in	a in (a1,a2,a3,...)	如果a在列表中，结果为true

-- 模糊查询

-- 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 
-- 查询学号为1000，1001的学员信息
SELECT * FROM `student`
WHERE `studentno` IN (1000,1001);
-- 查询在北京朝阳的学生
SELECT * FROM `student`
WHERE `address` IN (\'北京朝阳\');

-- null 和 not null
-- 查询地址非空的学员
SELECT * FROM `student`
WHERE `address` IS NOT NULL;
-- 查询姓名为空的学员
SELECT * FROM `student`
WHERE `studentname`=\'\' OR `studentname` IS NULL;

联表查询

/*
1.分析需要哪些表？
2.确定需要哪种连接？7种
3.确定交叉点，这两个表中哪个数据是相同的
4.判断的条件 学生表 `studentno`=成绩表 `studentno`
*/
-- 查询参加了考试的同学（学号，姓名，科目编号，分数）
-- inner join
/*
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` s -- 省略了as，下同
right JOIN `result` r
on s.`studentno`=r.`studentno`;
*/
-- left join
SELECT s.`studentno`,`studentname`,`subjectno`,`studentresult` 
FROM `student` s -- 省略了as，下同
LEFT JOIN `result` r
ON s.`studentno`=r.`studentno`;
-- 没参加考试的学生也查出来了

操作	描述
inner join	如果表中至少有一个匹配，就返回行
right join	会从右表中返回所有的值，即使左表中没有匹配
left join	会从左表中返回所有的值，即使右表中没有匹配

-- 查询缺考的同学
SELECT s.`studentno`,`studentname`,`subjectno`,`studentresult` 
FROM `student` s LEFT JOIN `result` r
ON s.`studentno`=r.`studentno`
WHERE `studentresult` IS NULL;

-- 查询参加考试的学生信息，学号，姓名，科目，分数
SELECT s.`studentno`,`studentname`,`subjectname`,`studentresult`
FROM `student` s
RIGHT JOIN `result` r
ON s.`studentno`=r.`studentno`
LEFT JOIN `subject` sub
ON r.`subjectno`=sub.`subjectno`;

练习：

-- 查询学生所属的年级，学号，姓名，年级
SELECT `studentno`,`studentname`,`gradename`
FROM `student` s
INNER JOIN `grade` g
ON s.`gradeid`=g.`gradeid`;
-- 查询科目所属的年级,科目，年级
SELECT `subjectname`,`gradename`
FROM `subject` sub
INNER JOIN `grade` g
ON sub.`gradeid`=g.`gradeid`;
-- 查询参加了高等数学-1和高等数学-2考试的学生信息，学号，姓名，科目名，分数
SELECT s.`studentno`,`studentname`,`subjectname`,`studentresult`
FROM `student` s
RIGHT JOIN `result` r
ON s.`studentno`=r.`studentno`
LEFT JOIN `subject` sub
ON r.`subjectno`=sub.`subjectno`
WHERE sub.`subjectname`=\'高等数学-1\' OR sub.`subjectname`=\'高等数学-2\';

自连接

自己的表和自己的表连接，一张表拆为两张一样的表。

-- 创建表
CREATE TABLE IF NOT EXISTS `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 `category` ( `categoryid`, `pid`, `categoryname` )
VALUES
( 2, 1, \'信息技术\'),
( 3, 1, \'软件开发\'),
( 5, 1, \'美术设计\' ),
( 4, 3, \'数据库\' ),
( 6, 3, \'web开发\' ),
( 7, 5, \'ps技术\' );

父类表：

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

子类表：

pid	categoryid	categoryname
3	4	数据库
3	6	web开发
5	7	ps技术

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

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

-- 查询父子信息
SELECT p.`categoryname` AS \'父栏目\',s.`categoryname` AS \'子栏目\'
FROM `category` AS p,`category` AS s
WHERE p.`categoryid`=s.`pid`;

分页和排序

排序：

-- 分页和排序
-- 排序：升序asc和降序desc
-- 查询参加了高等数学-1和高等数学-2考试的学生信息，学号，姓名，科目名，分数，
-- 按分数升序排列
SELECT s.`studentno`,`studentname`,`subjectname`,`studentresult`
FROM `student` s
RIGHT JOIN `result` r
ON s.`studentno`=r.`studentno`
LEFT JOIN `subject` sub
ON r.`subjectno`=sub.`subjectno`
WHERE sub.`subjectname`=\'高等数学-1\' OR sub.`subjectname`=\'高等数学-2\'
ORDER BY `studentresult` ASC; -- 升序

分页：

-- 查询参加了高等数学-1和高等数学-2考试的学生信息，学号，姓名，科目名，分数，
-- 按分数升序排列
-- 分页，每页只显示1条数据 语法：limit 起始数据 页面的大小
SELECT s.`studentno`,`studentname`,`subjectname`,`studentresult`
FROM `student` s
RIGHT JOIN `result` r
ON s.`studentno`=r.`studentno`
LEFT JOIN `subject` sub
ON r.`subjectno`=sub.`subjectno`
WHERE sub.`subjectname`=\'高等数学-1\' OR sub.`subjectname`=\'高等数学-2\'
ORDER BY `studentresult` ASC -- 升序
LIMIT 0,1; -- 当前页是第1页，起始数据第0条，每页1条数据
-- limit 1,1; -- 当前页是第2页，起始数据第1条，每页1条数据
/*
网页：当前页，每页数据，总页数
当前页第n页，起始数据（n-1）*m,每页数据m,总页数 数据总数/m
*/

练习：

-- 查询 高等数学-1 学校排名前10，并且分数>80分的学生成绩，学号，姓名，科目，分数
SELECT s.`studentno`,`studentname`,`subjectname`,`studentresult`
FROM `student` s
RIGHT JOIN `result` r
ON s.`studentno`=r.`studentno`
LEFT JOIN `subject` sub
ON sub.`subjectno`=r.`subjectno`
WHERE `subjectname`=\'高等数学-1\' AND `studentresult`>80
ORDER BY `studentresult` DESC
LIMIT 0,10;

子查询和嵌套

-- where语句中嵌套子查询语句
-- 1.查询 高等数学-1 的所有考试结果，学号，科目编号，成绩，降序排列
-- 方式一：使用连接查询
SELECT `studentno`,r.`subjectno`,`studentresult`
FROM `result` r
INNER JOIN `subject` sub
ON r.`subjectno`=sub.`subjectno`
WHERE `subjectname`=\'高等数学-1\'
ORDER BY `studentresult` DESC;
-- 方式二：使用子查询(由里及外)
SELECT `studentno`,`subjectno`,`studentresult`
FROM `result` 
WHERE`subjectno`=(
	SELECT `subjectno` FROM `subject` 
	WHERE `subjectname`=\'高等数学-1\'
)
ORDER BY `studentresult` DESC;
-- 2.查询分数不小于80分的学生的学号和姓名
SELECT `studentno`,`studentname`
FROM `student`
WHERE `studentno` IN (
	SELECT `studentno` FROM `result` 
	WHERE `studentresult`>=80
);
-- 3.查询 高等数学-1 分数不小于80分的学生的学号和姓名
SELECT s.`studentno`,`studentname`
FROM `student` s
RIGHT JOIN `result` r
ON s.`studentno`=r.`studentno`
WHERE r.`studentresult`>=80 AND `subjectno`=(
	SELECT `subjectno` FROM `subject` 
	WHERE `subjectname`=\'高等数学-1\'
);
-- 嵌套
-- 4.查询 高等数学-1 分数不小于80分的学生的学号和姓名
SELECT `studentno`,`studentname`
FROM `student`
WHERE `studentno` IN (
	SELECT `studentno` FROM `result` 
	WHERE `studentresult`>=80 AND `subjectno` = (
		SELECT `subjectno` FROM `subject`
		WHERE `subjectname`=\'高等数学-1\'
	)
);

mysql函数

常用函数

-- 数学运算
SELECT ABS(-8); -- 8 绝对值
SELECT CEILING(9.4); -- 10 向上取整
SELECT FLOOR(9.4); -- 9 向下取整
SELECT RAND(); -- 返回0-1之间的随机数
SELECT SIGN(-10); -- 符号函数 0-0 负数- -1 正数-1
-- 字符串函数
SELECT CHAR_LENGTH(\'fhjacdku2ed6789\'); -- 返回字符串长度 15
SELECT CONCAT(\'abc\',\'123\'); -- 连接字符串 abc123
SELECT INSERT(\'我喜欢编程\',2,2,\'超级热爱\'); -- 插入，替换 从第2 个字符开始替换，替换掉2个字符 我超级热爱编程
SELECT UPPER(\'sfhjjkDFG\'); -- 转换成大写 SFHJJKDFG
SELECT LOWER(\'sfhjjkDFG\'); -- 转换成小写 sfhjjkdfg
SELECT INSTR(\'sdfghjkl\',\'gh\'); -- 返回某字符串在字符串出现的位置 4
SELECT REPLACE(\'坚持就能成功\',\'坚持\',\'努力\'); -- 替换字符串 努力就能成功
SELECT SUBSTR(\'坚持就能成功\',2,4); -- 截取子字符串 持就能成 从第2个开始，截取4个字
SELECT REVERSE(\'sdfghjk\'); -- 反转字符串 kjhgfds

-- 查询姓 张 的同学，改为姓 王
SELECT REPLACE(`studentname`,\'张\',\'王\') FROM `student`
WHERE `studentname` LIKE \'张%\';

-- 时间和日期函数
SELECT CURRENT_DATE(); -- 获取当前日期 2021-10-02
SELECT CURDATE(); -- 获取当前日期 2021-10-02
SELECT NOW(); -- 获取当前时间 2021-10-02 13:08:14
SELECT LOCALTIME(); -- 获取本地时间 2021-10-02 13:08:14
SELECT SYSDATE(); -- 获取系统时间 2021-10-02 13:09:58
SELECT YEAR(NOW()); -- 年 2021
SELECT MONTH(NOW()); -- 月 10
SELECT DAY(NOW());-- 日 2
SELECT HOUR(NOW());-- 时 13
SELECT MINUTE(NOW());-- 分 13
SELECT SECOND(NOW());-- 秒 26

-- 系统
SELECT SYSTEM_USER(); -- 系统用户 root@localhost
SELECT USER(); -- 系统用户 root@localhost
SELECT VERSION(); -- 版本 5.7.35-log

聚合函数（常用）

函数名称	描述
count()	计数
sum()	求和
avg()	平均值
max()	最大值
min()	最小值

-- 聚合函数
-- 查询表中有多少条记录
SELECT COUNT(`studentno`) FROM `student`; -- 2 2个学生学号,null值不计算在内
SELECT COUNT(*) FROM `student`; -- 2 2个学生学号，null值计算在内
SELECT COUNT(1) FROM `student`; -- 2 2个学生学号，null值计算在内
-- 计算学生成绩的总和
SELECT SUM(`studentresult`) AS \'成绩总和\' FROM `result`; -- 379
-- 计算学生成绩的平均分
SELECT AVG(`studentresult`) AS \'成绩平均分\' FROM `result`; -- 75.8
-- 计算学生成绩的最高分
SELECT MAX(`studentresult`) AS \'成绩最高分\' FROM `result`; -- 98
-- 计算学生成绩的最低分
SELECT MIN(`studentresult`) AS \'成绩最低分\' FROM `result`; -- 58

-- 查询某门课程的平均分，最高分，最低分
SELECT AVG(`studentresult`) AS \'平均分\',MAX(`studentresult`) AS \'最高分\',MIN(`studentresult`) AS \'最低分\' 
FROM `result` r
INNER JOIN `subject` s
ON r.`subjectno`=s.`subjectno`
WHERE `subjectname`=\'高等数学-1\';

分组与过滤

-- 分组与过滤
-- 查询不同课程的平均分，最高分，最低分，平均分大于60分的结果
SELECT `subjectname` AS \'科目名称\',AVG(`studentresult`) AS \'平均分\',MAX(`studentresult`) AS \'最高分\',MIN(`studentresult`) AS \'最低分\' 
FROM `result` r
INNER JOIN `subject` s
ON r.`subjectno`=s.`subjectno`
GROUP BY r.`subjectno`
HAVING 平均分>=60;

数据库级别的MD5加密

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

-- 明文密码
INSERT INTO `testmd5` VALUES(1,\'张三\',\'123456\'),(2,\'李四\',\'123456\'),(3,\'王五\',\'123456\');

-- 加密
UPDATE `testmd5` SET pwd=MD5(pwd) WHERE `id`=1; -- 加密id=1的密码
UPDATE `testmd5` SET pwd=MD5(pwd); -- 加密所有密码,此时id=1的被加密了两次

-- 插入的时候加密
INSERT INTO `testmd5` VALUES(4,\'小明\',MD5(\'abc456\'));

-- 校验：将用户传递的密码进行md5加密，比对加密后的值
SELECT * FROM `testmd5` WHERE `pwd`=MD5(\'123456\');

select小结

6.事务

什么是事务

执行事务

-- 事务
-- 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\',10000.00);

-- 模拟转账：事务
SET autocommit=0;
START TRANSACTION;
UPDATE `account` SET `money`=`money`-500 WHERE `name`=\'A\';
UPDATE `account` SET `money`=`money`+500 WHERE `name`=\'B\';
COMMIT;
ROLLBACK;
SET autocommit=1;

7.索引

索引的分类

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

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

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

-- 分析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 \'\' COMMENT \'用户名称\',
 `email` VARCHAR(50) NOT NULL COMMENT \'用户邮箱\',
 `phone` VARCHAR(20) DEFAULT \'\' COMMENT \'电话号\',
 `gender` TINYINT(4) UNSIGNED DEFAULT \'0\' COMMENT \'性别（0:男；1:女）\',
 `password` VARCHAR(100) NOT NULL COMMENT \'密码\',
 `age` TINYINT(4) DEFAULT \'0\' COMMENT \'年龄\',
 `create_time` DATETIME DEFAULT CURRENT_TIMESTAMP,
 `update_time` TIMESTAMP NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
 PRIMARY KEY(`id`)
)ENGINE = INNODB DEFAULT CHARSET = utf8mb4 COMMENT = \'app用户表\';

-- 插入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`,`email`,`phone`,`gender`,`password`,`age`)
		VALUES(CONCAT(\'用户\',i),\'2792178110@qq.com\',
		CONCAT(\'18\',FLOOR(RAND()*((999999999-100000000)+100000000))),
		FLOOR(RAND()*2),UUID(),FLOOR(RAND()*100));
		SET i=i+1;
	END WHILE;
	RETURN i;
END;

SELECT mock_data(); -- 1000000

SELECT * FROM `app_user`; -- 0.018 sec
SELECT * FROM `app_user` WHERE `name`=\'用户9999\'; -- 0.602 sec
SELECT * FROM `app_user` WHERE `name`=\'用户999999\'; -- 0.635 sec
EXPLAIN SELECT * FROM `app_user` WHERE `name`=\'用户999999\'; -- 992660rows

-- CREATE INDEX 索引名 ON 表（字段）
CREATE INDEX id_app_user_name ON `app_user`(`name`);

SELECT * FROM `app_user` WHERE `name`=\'用户999999\'; -- 0.013 sec
EXPLAIN SELECT * FROM `app_user` WHERE `name`=\'用户999999\'; -- 1rows

索引原则

8.数据库权限管理和备份

用户管理

sqlyog可视化管理

sql命令操作：

-- `mysql`-`user` 增删改查
-- 创建用户
CREATE USER mingmao IDENTIFIED BY \'123456\';
-- 修改密码,当前用户
SET PASSWORD=PASSWORD(\'123456\');
-- 修改密码，指定用户
SET PASSWORD FOR mingmao =PASSWORD(\'123456\');
-- 用户重命名
RENAME USER mingmao TO mingmao0;
-- 用户授权 库.表
-- 除了给其他用户授权，其他权限都有
GRANT ALL PRIVILEGES ON *.* TO mingmao0; -- 全部库的全部表
-- 查看权限
SHOW GRANTS FOR mingmao0; -- 查看指定用户的权限
SHOW GRANTS FOR root@localhost; -- 查看主机权限
-- 撤销权限
REVOKE ALL PRIVILEGES ON *.* FROM mingmao0;
-- 删除用户
DROP USER mingmao0;

数据备份

sqlyog备份
导出：

导入：

命令行操作：

# 导出一张表
mysqldump -hlocalhost -uroot -p123456 school student >d:/a.sql
# 导出多张表
mysqldump -hlocalhost -uroot -p123456 school student result >d:/a.sql
# 导出数据库
mysqldump -hlocalhost -uroot -p123456 school >d:/a.sql
# 导入
mysql -uroot -p123456
use school;
source d:/a.sql

9.数据库的规约，三大范式

数据库设计

三大范式

10.JDBC

数据库驱动

JDBC

数据库驱动包

第一个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\', \'zs@sina.com\',\'1980-12-04\'),
(2, \'lisi\',\'123456\', \'lisi@sina.com\',\'1981-12-04\'),
(3, \'wangwu\',\'123456\',\'wangwu@sina.com\',\'1979-12-04\');

package com.mingmao.test1;

import java.sql.*;

public class JdbcTest01 {
    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("password="+resultSet.getObject("password"));
            System.out.println("email="+resultSet.getObject("email"));
            System.out.println("birthday="+resultSet.getObject("birthday"));
        }
        // 6.释放链接
        resultSet.close();
        statement.close();
        connection.close();
    }
}

statement对象

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

package com.mingmao.test2.utils;

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

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{
            // 获得 db.properties中的内容
            InputStream resourceAsStream = JdbcUtils.class.getClassLoader().getResourceAsStream("db.properties");
            Properties properties = new Properties();
            properties.load(resourceAsStream);

            // 读取内容
            driver=properties.getProperty("driver");
            url=properties.getProperty("url");
            username=properties.getProperty("username");
            password=properties.getProperty("password");

            // 1.驱动只用加载一次
            Class.forName(driver);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    //获取连接
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url, username, password);
    }
    // 释放资源
    public static void release(Connection connection, Statement statement, ResultSet resultSet){
        if(resultSet!=null){
            try {
                resultSet.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(statement!=null){
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(connection!=null){
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

package com.mingmao.test2;

import com.mingmao.test2.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class testInsert {
    public static void main(String[] args) {
        Connection connection=null;
        Statement statement=null;
        ResultSet resultSet=null;

        try {
            // 1.获取数据库连接，创建数据库对象
            connection = JdbcUtils.getConnection();
            // 2. 执行sql的对象
            statement = connection.createStatement();
            // 3.执行sql,插入数据
            String sql="INSERT INTO `users`"+"VALUES (5,\'小明\',\'123456\',\'xiaoming@qq.com\',\'2010-01-01\')";
            int i = statement.executeUpdate(sql);
            if(i>0){
                System.out.println("插入成功！");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            JdbcUtils.release(connection,statement,resultSet);
        }

    }
}

package com.mingmao.test2;

import com.mingmao.test2.utils.JdbcUtils;

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

public class TestDelete {
    public static void main(String[] args) {
        Connection connection=null;
        Statement statement=null;
        ResultSet resultSet=null;

        try {
            // 1.获取数据库连接，创建数据库对象
            connection = JdbcUtils.getConnection();
            // 2. 执行sql的对象
            statement = connection.createStatement();
            // 3.执行sql,删除数据
            String sql="DELETE FROM `users` WHERE `id`=4";
            int i = statement.executeUpdate(sql);
            if(i>0){
                System.out.println("删除成功！");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            JdbcUtils.release(connection,statement,resultSet);
        }
    }
}

package com.mingmao.test2;

import com.mingmao.test2.utils.JdbcUtils;

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

public class TestUpdate {
    public static void main(String[] args) {
        Connection connection=null;
        Statement statement=null;
        ResultSet resultSet=null;

        try {
            // 1.获取数据库连接，创建数据库对象
            connection = JdbcUtils.getConnection();
            // 2. 执行sql的对象
            statement = connection.createStatement();
            // 3.执行sql,更新数据
            String sql="UPDATE `users` SET `name`=\'mingmao\' WHERE `id`=2";
            int i = statement.executeUpdate(sql);
            if(i>0){
                System.out.println("更新成功！");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            JdbcUtils.release(connection,statement,resultSet);
        }
    }
}

package com.mingmao.test2;

import com.mingmao.test2.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) {
        Connection connection=null;
        Statement statement=null;
        ResultSet resultSet=null;

        try {
            // 1.获取数据库连接，创建数据库对象
            connection = JdbcUtils.getConnection();
            // 2. 执行sql的对象
            statement = connection.createStatement();
            // 3.执行sql,查询数据
            String sql="SELECT * FROM `users` WHERE `id`=2";
            resultSet = statement.executeQuery(sql);
            while(resultSet.next()){
                System.out.println(resultSet.getString("name"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            JdbcUtils.release(connection,statement,resultSet);
        }
    }
}

sql注入

package com.mingmao.test2;

import com.mingmao.test2.utils.JdbcUtils;

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

public class SQL注入 {
    public static void main(String[] args) {
        //login("zhansan","123456"); 正常登录
        login("\'or \'1=1","\'or\'1=1");// 查处所有用户，不安全

    }
    // 登录业务
    public static void login(String username,String password){
        Connection connection=null;
        Statement statement=null;
        ResultSet resultSet=null;

        try {
            // 1.获取数据库连接，创建数据库对象
            connection = JdbcUtils.getConnection();
            // 2. 执行sql的对象
            statement = connection.createStatement();
            // 3.执行sql,查询数据
            String sql="SELECT * FROM `users` WHERE `name`=\'"+username+"\' AND `password`=\'"+password+"\'";
            resultSet = statement.executeQuery(sql);
            while(resultSet.next()){
                System.out.println(resultSet.getString("name"));
                System.out.println(resultSet.getString("password"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            JdbcUtils.release(connection,statement,resultSet);
        }
    }
}

preparedstatement对象

package com.mingmao.test3;

import com.mingmao.test2.utils.JdbcUtils;

import java.sql.*;

public class TestInsert {
    public static void main(String[] args) {
        Connection connection=null;
        PreparedStatement preparedStatement=null;

        try {
            connection = JdbcUtils.getConnection();
            // 使用?占位符代替参数
            String sql="INSERT INTO `users` VALUES (?,?,?,?,?)";
            //预编译sql,先写sql，不执行
            preparedStatement = connection.prepareStatement(sql);
            // 手动给参数赋值
            preparedStatement.setInt(1,5);// id=5
            preparedStatement.setString(2,"小明");
            preparedStatement.setString(3,"123456");
            preparedStatement.setString(4,"xiaoming@qq.com");
            //preparedStatement.setString(5,"2010-01-01");
            preparedStatement.setDate(5,new java.sql.Date(new java.util.Date().getTime()));
            //执行
            int i = preparedStatement.executeUpdate();
            if(i>0){
                System.out.println("插入成功！");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.release(connection,preparedStatement,null);
        }
    }
}

package com.mingmao.test3;

import com.mingmao.test2.utils.JdbcUtils;

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

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

        try {
            connection = JdbcUtils.getConnection();
            // 使用?占位符代替参数
            String sql="DELETE FROM `users` WHERE `id`=?";
            //预编译sql,先写sql，不执行
            preparedStatement = connection.prepareStatement(sql);
            // 手动给参数赋值
            preparedStatement.setInt(1,5);// id=5
            //执行
            int i = preparedStatement.executeUpdate();
            if(i>0){
                System.out.println("删除成功！");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.release(connection,preparedStatement,null);
        }
    }
}

package com.mingmao.test3;

import com.mingmao.test2.utils.JdbcUtils;

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

public class TestUpdate {
    public static void main(String[] args) {
        Connection connection=null;
        PreparedStatement preparedStatement=null;

        try {
            connection = JdbcUtils.getConnection();
            // 使用?占位符代替参数
            String sql="UPDATE `users` SET `name`=? WHERE `id`=?";
            //预编译sql,先写sql，不执行
            preparedStatement = connection.prepareStatement(sql);
            // 手动给参数赋值
            preparedStatement.setString(1,"mingmao");
            preparedStatement.setInt(2,4);// id=4
            //执行
            int i = preparedStatement.executeUpdate();
            if(i>0){
                System.out.println("更新成功！");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.release(connection,preparedStatement,null);
        }
    }
}

package com.mingmao.test3;

import com.mingmao.test2.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) {
        Connection connection=null;
        PreparedStatement preparedStatement=null;
        ResultSet resultSet=null;
        try {
            connection = JdbcUtils.getConnection();
            // 使用?占位符代替参数
            String sql="SELECT * FROM `users` WHERE `id`=?";
            //预编译sql,先写sql，不执行
            preparedStatement = connection.prepareStatement(sql);
            // 手动给参数赋值
            preparedStatement.setInt(1,4);// id=4
            //执行
            resultSet = preparedStatement.executeQuery();
            while(resultSet.next()){
                System.out.println(resultSet.getString("name"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.release(connection,preparedStatement,resultSet);
        }
    }
}

package com.mingmao.test3;

import com.mingmao.test2.utils.JdbcUtils;

import java.sql.*;

public class SQL注入 {
    public static void main(String[] args) {
         login("zhansan","123456"); // 正常登录
       // login("\'\' or 1=1","123456");// 什么都查不出来，安全
    }
    // 登录业务
    public static void login(String username,String password){
        Connection connection=null;
        PreparedStatement preparedStatement=null;
        ResultSet resultSet=null;

        try {
            connection = JdbcUtils.getConnection();
            String sql="SELECT * FROM `users` WHERE `name`=? AND `password`=?";
            preparedStatement =connection.prepareStatement(sql);
            preparedStatement.setString(1,username);
            preparedStatement.setString(2,password);
            resultSet = preparedStatement.executeQuery();
            while(resultSet.next()){
                System.out.println(resultSet.getString("name"));
                System.out.println(resultSet.getString("password"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            JdbcUtils.release(connection,preparedStatement,resultSet);
        }
    }
}

使用IDEA连接数据库

从mysql的片段中加载ListView

连接MySQL出现错误：ERROR 1045 (28000): Access denied for user ‘root‘@‘localhost‘ (using password: YES)(代码片段

使用 json rereiver php mysql 在片段中填充列表视图

关于mysql驱动版本报错解决，Cause: com.mysql.jdbc.exceptions.jdbc4Unknown system variable ‘query_cache_size(代码片段

修改MySQL密码报错“ERROR 1819 (HY000): Your password does not satisfy the current policy requirements“(代码片段

mysql查看版本的四种方法