MySQL基础知识(配合Navicat使用)
文章目录
- 数据库的基本概念
- MySQL简介
- 连接数据库
- 操作数据库
- 操作数据库(了解)
- 数据库的列类型
- 数据库的字段属性(重点)
- 创建数据库表(重点)
- 数据表的类型
- 修改删除表
- MySQL数据管理
- 外键(了解即可)
- DML语言(全部记住)
- 添加
- 修改
- 删除
- DQL查询数据(非常重要)
- 查询指定字段
- where 条件语句
- 联表查询
- 分页和排序
- 子查询
- 分组和过滤
- MySQL函数
- 常用函数
- 聚合函数
- 数据库级别的MD5加密(了解即可)
- 事务(重要)
- 隔离导致的一些问题
- 索引
- 索引的分类
- 测试索引
- 索引原则
- 权限管理和备份
- 用户管理
- MySQL备份
- 规范数据库设计
- 设计数据库的步骤
- 三大范式
- JDBC(***)
- 数据库驱动
- JDBC
- JDBC程序
- Statement对象
- SQL注入问题
- PreparedStatement对象
数据库的基本概念
数据(Data), 数据库(DataBase,DB), 数据库管理系统(DataBase Management System,DBMS),
数据库系统(DataBase System,DBS), 数据库应用系统(DataBase Application System,DBAS)
关系型数据库:
- MySQL,Oracle,SqlServer,DB2,SQLlite
- 通过表和表之间,行和列之间的关系进行数据的存储,例如:学院信息表,考勤表
非关系型数据库:
- Redis,MongoDB
- 非关系型数据库,对象存储,通过对象的自身的属性来决定
数据库管理系统DBMS:
- 数据的管理软件,科学有效的管理我们的数据。维护和获取数据
- MySQL,数据库管理系统
MySQL简介
MySQL是一个**关系型数据库管理系统**
MySQL是最好的 RDBMS (Relational Database Management System,关系数据库管理系统)
MySQL是一种关系型数据库管理系统,关系数据库将数据保存在不同的表中,而不是将所有数据放在一个大仓库内,这样就增加了速度并提高了灵活性。
MySQL所使用的 SQL 语言是用于访问数据库的最常用标准化语言
连接数据库
show databases; -- 查看所有的数据库mysql> use school; -- 切换数据库 use 数据库名
Database changedshow tables; -- 查看数据库中所有的表desc student; -- 显示数据库中所有表的信息exit; -- 退出连接-- 代表单行注释
/*
多行注释
*/
数据库xxx语言:
DDL 定义
DML 操作
DQL 查询
DCL 控制
操作数据库
操作数据库(了解)
- 创建数据库
CREATE DATABASE [IF NOT EXISTS] westos;
- 删除数据库
DROP DATABASE [IF EXISTS] hello;
- 使用数据库
USE school;
- 查看所有数据库
SHOW DATABASES;
数据库的列类型
数值-
- tinyint 十分小的数据 1个字节
- smallint 较小的数据 2个字节
- mediumint 中等大小的数据 3个字节
- **int 标准的整形 4个字节 ****
- bigint 较大的数据 8个字节
- float 浮点数 4个字节
- double 浮点数 8个字节
- decimal 字符串形式的浮点数 金融计算的时候一般使用
字符串
- char 字符串的固定大小 0~255
- varchar 可变字符串 0~65535 和java中的String相似
- tinytext 微型文本 2^8 - 1
- text 文本串 2^16 - 1 保存大文本
时间日期
- 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来填充
自增:设置自增类型的字段,需要将其设置为主键,否则会报错
- 通常可以理解为自增,自动在上一条记录的基础上 +1 (默认)
- 通常用来设计唯一的主键~ index,必须是整数类型
- 可以自定义设计主键自增的起始值和步长
非空 null not null
- 假设设置为not nul ,如果不给它赋值,就会报错
- NULL,如果不填写,默认就是null
默认:
- 设置默认的值,需要加 ’ ’ (英文的)
- sex,默认值为男,如果不指定该列的值,则会有默认的值
创建数据库表(重点)
-- 注意点,使用英文(),表的名称 和 字段 尽量使用 `` 括起来
-- AUTO_INCREMENT 自增
-- 字符串使用 单括号'' 括起来
-- 所有的语句后面加 ,(英文的) ,最后一个不用加
-- PRIMARY KEY 主键,一般一个表只有一个唯一的主键
CREATE TABLE IF NOT EXISTS `student` (`id` INT(4) NOT NULL AUTO_INCREMENT COMMENT '学号',`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
格式:
CREATE TABLE [IF NOT EXISTS] `表名`('字段名' 列类型 [属性] [索引] [注释],'字段名' 列类型 [属性] [索引] [注释],.....'字段名' 列类型 [属性] [索引] [注释],
)[表类型][字符集设置][注释]
navicat查看创建数据库的语句,数据表的语句和表的结构
-- 1.
SHOW CREATE DATABASE school --查看创建数据库的语句
-- 2.
SHOW CREATE TABLE student --查看student数据表的定义语句
-- 3.
DESC student --显示表的结构
运行结果:
-- 1.
CREATE DATABASE `school` /*!40100 DEFAULT CHARACTER SET utf8 */
-- 2.
-- 逆向操作,先创建一个数据表,然后在查看
CREATE TABLE `student` (`id` int(4) NOT NULL AUTO_INCREMENT COMMENT '学号',`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
-- 3.
数据表的类型
--关于数据库的引擎
/*
INNODB 默认使用
MYISAM 早些年使用
*/
MYISAM | INNODB | |
---|---|---|
事务支持 | 不支持 | 支持 |
数据行锁定 | 不支持 | 支持 |
外键约束 | 不支持 | 支持 |
全文索引 | 支持 | 不支持 |
表空间大小 | 较小 | 较大,约为2倍 |
常规使用操作:
- MYISAM 节约空间,速度较快
- INNODB 安全性高,事务的处理,多表多用户操作
在物理空间存在的位置
所有的数据库文件都存在data目录下,一个文件夹就对应一个数据库
本质还是文件的存储!
MySQL引擎在物理文件上的区别
- INNODB 在数据库表中只有一个*.firm文件,以及上级目录下的 ibdata1 文件
- MYISAM对应文件
- *.firm 表结构文件
- *.MYD 数据文件(data)
- *.MYI 索引文件(index)
设置数据库表的字符集编码
CHARSET=utf8
不设置的话,会是MySQL默认的字符据编码~(不支持中文!)
MySQL的默认编码是latin1,不支持中文
在my.ini中配置默认的编码
character_set_server=utf8
修改删除表
修改
-- 修改表名ALTER TABLE 旧表名 RENAME AS 新表名
ALTER TABLE teacher RENAME AS teacher01-- 增加表的字段 ALTER TABLE 表名 ADD 字段名 列属性
ALTER TABLE teacher01 ADD age INT(11)-- 修改表的字段名 (重命名,修改约束!)
-- ALTER TABLE 表名 MODIFY 字段名 列属性[]
ALTER TABLE teacher01 MODIFY age VARCHAR(11) -- 修改约束-- ALTER TABLE 表名 CHANGE 旧字段名 新字段名 列属性[]
ALTER TABLE teacher01 CHANGE age age1 INT(10) -- 字段重命名
-- change一般用来字段重命名,modify修改约束-- 删除表的字段名 ALTER TABLE 表名 DROP 字段名
ALTER TABLE teacher01 DROP age1
删除
-- 删除表(如果表存在再删除)
DROP TABLE [IF EXISTS] teacher01
所有的创建和删除操作尽量加上判断,以免报错
注意点:
- `` 字段名使用这个包裹!
- 注释 – /* */
- sql关键字大小写不敏感,一般使用小写
- 所有的符号全部用英文
MySQL数据管理
外键(了解即可)
方式一:在创建表的时候,增加约束,(麻烦,比较复杂)
CREATE TABLE `grade` (`gradeid` INT(10) NOT NULL AUTO_INCREMENT COMMENT '年级id',`gradename` VARCHAR(20) NOT NULL COMMENT '年级名称',PRIMARY KEY (`gradeid`)) ENGINE=InnoDB DEFAULT CHARSET=utf8;-- 学生表的 gradeid 字段 要去引用年级表的 gradeid
-- 定义外键key
-- 给这个外键添加约束 (执行引用) references 引用
CREATE TABLE `student` (`id` int(4) NOT NULL AUTO_INCREMENT COMMENT '学号',`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 '出生日期',`gradeid` INT(10) NOT 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(20) NOT NULL COMMENT '年级名称',PRIMARY KEY (`gradeid`)) ENGINE=InnoDB DEFAULT CHARSET=utf8;-- 学生表的 gradeid 字段 要去引用年级表的 gradeid
-- 定义外键key
-- 给这个外键添加约束 (执行引用) references 引用
CREATE TABLE `student` (`id` int(4) NOT NULL AUTO_INCREMENT COMMENT '学号',`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 '出生日期',`gradeid` INT(10) NOT NULL COMMENT '学生的年级',`address` varchar(100) DEFAULT NULL COMMENT '家庭住址',`email` varchar(50) DEFAULT NULL COMMENT '邮箱',PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;-- 创建表的时候没有外键关系
-- ALTER TABLE 表名 ADD CONSTRAINT 约束名 FOREIGN KEY (作为外键的列)REFERENCES 哪个表(哪个字段)
ALTER TABLE `student`
ADD CONSTRAINT `FK_gradeid` FOREIGN KEY (`gradeid`) REFERENCES `grade` (`gradeid`);
以上的操作都是物理外键,数据库级别的外键,不建议使用!(避免数据库过多造成困扰,了解即可!!!!)
最佳实践:
- 数据库就是单纯的表,只用来存数据,只有行(数据)和列(字段)
- 相使用多张表的数据,使用外键(程序区实现)
DML语言(全部记住)
数据库的意义:数据存储,数据管理
DML语言:数据操作语言
- insert,update,delete
添加
insert
-- 插入语句
-- insert into 表名([字段1,字段2,....]) values('值1'),('值2'),('值3')...
INSERT INTO `grade` (`gradename`) VALUES('大四')-- 由于主键自增我们可以省略(如果不写表的字段名,他就会一一匹配)
INSERT INTO `grade` VALUES('大三') -- 语句报错,没有一一匹配
-- 一般写入插入语句,我们一定要数据和字段一一对应!
-- 插入多个字段
INSERT INTO `grade` (`gradename`)
VALUES('大二'),('大一')INSERT INTO `student`(`name`) VALUES('张三')-- 可以同时插入多条语句,VALUSES后面的值,隔开即可VALUES(),(),...
INSERT INTO `student`(`name`,`pwd`,`sex`)
VALUES('李四','aaaaaa','男'),('王五','aaabbbba','男')-- 字段可以省略,但后面的值必须要一一对应,否则报错
INSERT INTO `student`
VALUES(4,'李四','aaaabb','男','2000-01-01','西安','email')
语法:insert into 表名([字段1,字段2,…]) values(‘值1’),(‘值2’),(‘值3’)…
注意事项:
- 字段和字段之间使用英文逗号隔开
- 字段可以省略,但后面的值必须要一一对应,否则报错
- 可以同时插入多条语句,VALUSES后面的值,隔开即可VALUES(),(),…
修改
update
-- 语法:UPDATE 表名 SET column_name=value WHERE [条件]-- 修改学员的名字,带了条件
UPDATE `student` SET `name`='狂神' WHERE id=1;-- 不指定条件的情况下,会改动所有的表
UPDATE `student` SET `name`='sgl';-- 修改多个属性
UPDATE `student` SET `name`='coco',`email`='2259567490@qq.comm' WHERE id=1;-- 通过多个条件定位数据
UPDATE `student` SET `name`='长江7号' WHERE `name`='two' AND `sex`='男' AND `address`='西安';
操作符会返回 布尔值
操作符 | 含义 | 范围 | 结果 |
---|---|---|---|
= | 等于 | ||
<> 或 != | 不等于 | ||
> | |||
< | |||
>= | |||
<= | |||
BETWEEN … AND … | 在某个范围 | 闭区间 [x,y] | |
AND | 我和你 && | ||
OR | 我或你 || |
语法:UPDATE 表名 SET column_name=value,[column_name=value,…] WHERE [条件]
注意:
- column_name 是数据库的列,尽量带上 ``
- 条件,筛选的条件,如果没有指定将会修改所有的列
- value,是一个具体的值,也可以是一个变量
UPDATE `student` SET `birthday`=CURRENT_TIME WHERE `name`='长江7号' AND `address`='西安';
-- CURRENT_TIME WHERE 返回当前时间,是一个变量
删除
delete
-- 删除数据 (避免这样写,会全部删除)
DELETE FROM `student`-- 删除指定数据
DELETE FROM `student` WHERE id=1;
TRUNCATE 命令
作用:完全清空一个数据库表,表的结构和索引约束不会变!
-- 清空 student 表
TRUNCATE `student`
TRUNCATE 和 delete 的区别
- 相同点:都能删除数据库,都不会删除表结构
- 不同点:
- TRUNCATE:重新设置自增列 计数器回归零,重1开始
- TRUNCATE 不会影响事务
-- 测试TURUNCATE和delete的区别
CREATE TABLE `test`(`id` INT(4) NOT NULL AUTO_INCREMENT ,`coll` VARCHAR(20) NOT NULL,PRIMARY KEY(`id`)) ENGINE=INNODB DEFAULT CHARSET=utf8INSERT INTO `test`(`coll`) VALUES('a'),('b'),('c')DELETE FROM `test` -- 不会影响自增TRUNCATE TABLE `test` -- 自增会归零,重1开始
了解即可: DElETE删除的问题,重启数据库,现象:
- INNODB:自增量会从1开始(存在内存档中,断电即失)
- MYISAM:继续从上一个自增量开始(存在文件中,不会丢失)
DQL查询数据(非常重要)
(Data Query LANGUAGE:数据查询语言)
select完整语句:
SELECT[ALL|DISTINCT|DISTINCTROW|TOP]
{*|talbe.*|[table.]field1[AS alias1][,[table.]field2[AS alias2][,…]]}
FROM tableexpression[,…][IN externaldatabase]
[WHERE…] -- 指定结果需满足的条件
[GROUP BY…] -- 指定结果按照哪个字段来分组
[HAVING…] -- 过滤分组的记录必须满足的次要条件
[ORDER BY…] -- 指定查询记录按一个或多个条件排序
[ LIMIT {[offset,] row_count | row_countoffset offset}]-- 指定查询的记录从哪条至哪条
注意 Where,GroupBy,Having,OrderBy 顺序
查询指定字段
-- 查询全部的学生 SELECT 字段 FROM 表
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 别名
-- 别名 ,给结果起一个名字 AS 可以给字段起别名也可以表起别名
SELECT `StudentNo` AS 学号,`StudentName` AS 学生姓名 FROM `student` AS s
去重 distinct
作用:去除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 ! | not a !a | 逻辑非,真为假,假为真 |
-- 查询考试成绩再95-100之间 AND 和 &&
SELECT `studentNo`,`studentResult` FROM `result` -- 字段名也可以不区分大小写SELECT `StudentNo`,`StudentResult` FROM `result`
WHERE StudentResult>=95 AND StudentResult<=100SELECT `StudentNo`,`StudentResult` FROM `result`
WHERE StudentResult>=95 && StudentResult<=100-- 模糊查询(区间)
SELECT `StudentNo`,`StudentResult` FROM `result`
WHERE StudentResult BETWEEN 95 AND 100-- != 和 NOT
SELECT `StudentNo`,`StudentResult` FROM `result`
WHERE StudentNo!=1000SELECT `StudentNo`,`StudentResult` FROM `result`
WHERE NOT StudentNo=1000
模糊查询:比较运算符
运算符 | 语法 | 描述 |
---|---|---|
IS NULL | a is null | 如果操作符为NULL,结果为真 |
IS NOT NULL | a is not null | 如果操作符不为NULL,结果为真 |
BETWEEN | a between b and c | 若在b和c之间,结果为真 |
LIKE | a like b | SQL匹配,如果a匹配b,结果为真 |
IN | a in(a1,a2,a2…) | 假设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` IS NOT NULL-- 查询出生日期 为空 的同学SELECT `StudentNo`,`StudentName` FROM `student`
WHERE `BornDate` IS NULL
联表查询
操作 | 描述 |
---|---|
inner join | 如果表中至少有一个匹配(公共的,即交集),就返回 |
right join | 会从右边返回所有的值,即使左边没有匹配(右边有左边没有,以右边为齐,即返回公共的,加上右边有的) |
left join | 会从左边返回所有的值,即使右边没有匹配(左边有右边没有,以左边为齐,即返回公共的,加上左边有的) |
-- ======================联表查询 join =====================
-- 查询参加了考试的同学(学号,姓名,科目编号,分数)
SELECT * FROM student
SELECT * FROM result/*思路
1.分析需求,分析查询的字段来自哪些表,(连接查询)
2.确定交叉点(这两个表中哪个数据是相同的)
判断条件:学生表中的 StudentNo = 成绩表中 StudentNo
*/-- join(连接的表)on(判断条件)连接查询
-- WHERE 等值查询-- INNER JOIN
SELECT s.StudentNo,StudentName,SubjectNo,StudentResult
FROM student AS s INNER JOIN result AS r
ON s.StudentNo = r.StudentNo-- RIGHT JOIN
SELECT s.StudentNo,StudentName,SubjectNo,StudentResult
FROM student s RIGHT JOIN result r
ON s.StudentNo = r.StudentNo-- LEFT JOIN
SELECT s.StudentNo,StudentName,SubjectNo,StudentResult
FROM student s LEFT JOIN result r
ON s.StudentNo = r.StudentNo-- 查询缺考的同学
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 r.StudentNo = s.StudentNo
INNER JOIN `subject` sub
ON r.SubjectNo = sub.SubjectNo
总结:
- 我们要查询哪些数据 select…
- 从哪几个表中查 FROM 表 XXX Join 连接的表 ON 交叉条件
- 假设存在查询多张表,慢慢来,先查询两张表,再慢慢增加
FROM a left join b
FROM a right join b
自连接
自己的表和自己的表连接,核心:一张表拆为两张表
父类
pid | categoryName |
---|---|
2 | 信息技术 |
3 | 软件开发 |
5 | 美术技术 |
子类
pid | categoryid | categoryName |
---|---|---|
3 | 4 | 数据库 |
3 | 6 | web开发 |
5 | 7 | ps技术 |
2 | 8 | 办公信息 |
操作:查询父类对应的子类的关系
父类 | 子类 |
---|---|
信息技术 | 办公信息 |
软件开发 | 数据库 |
软件开发 | web开发 |
美术技术 | ps技术 |
-- 查询父子关系
SELECT a.`categoryName` AS '父栏目',b.`categoryName` AS '子栏目'
FROM `category` AS a,`category` AS b
WHERE a.categoryid = b.pid -- 父类的categoryid对应子类的pid(即相同,不同表达)
练习:
-- 查询学员所属的年级(学号,姓名,年级名称)
SELECT StudentNo ,StudentName,GradeName
FROM student AS s
INNER JOIN grade AS g
ON s.GradeID = g.GradeID-- 查询科目所属年级(科目名称,年级名称)
SELECT SubjectName,GradeName
FROM `subject` sub
INNER JOIN grade gra
ON sub.GradeID = gra.GradeID-- 查询了参加高等数学 考试的同学信息:学号,学生姓名,科目名,分数
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 sub.SubjectNo = r.SubjectNo
WHERE SubjectName = '高等数学'
分页和排序
排序
-- ==============分页limit和排序order by==================
-- 排序:降序DESC 升序ASC
-- ORDER BY 哪个字段排序 怎么排
-- 查询结果根据 成绩 降序DESC 升序ASCSELECT 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 sub.SubjectNo = r.SubjectNo
WHERE SubjectName = '高等数学'
ORDER BY StudentResult DESC
分页
-- 分页 语法:limit 当前页,页面的大小
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 sub.SubjectNo = r.SubjectNo
WHERE SubjectName = '高等数学'
ORDER BY StudentResult DESC
LIMIT 5,5-- 第一页 limit 0,5 (1-1)*5,5
-- 第二页 limit 5,5 (2-1)*5,5
-- 第三页 limit 10,5 (3-1)*5,5
-- 第N页 limit (n-1)*pageSize,pageSize
-- 【pageSize:页面当前大小】
-- 【(n-1)*pageSize:起始值】
-- 【n:当前页】
-- 【页面总数/页面大小 = 总页数】
练习:
-- 查询高等英语 课程成绩排名前三的学生,并且分数要大于80的学生信息(学号,姓名,课程名称,分数)SELECT stu.StudentNo,StudentName,SubjectName,StudentResult
FROM student AS stu
INNER JOIN `result` AS res
ON stu.StudentNo = res.StudentNo
INNER JOIN `subject` AS sub
ON res.SubjectNo = sub.SubjectNo
WHERE SubjectName = '高等英语'
ORDER BY StudentResult DESC
LIMIT 0,3
子查询
where(这个值是计算出来的)
本质:在where语句中嵌套一个子查询语句
where(select * from)
-- =================WHERE================
-- 查询高等英语的所有考试结果(学号,课程编号,成绩),降序排列
-- 方式一:连接查询
SELECT StudentNo,r.SubjectNo,StudentResult
FROM result r
INNER JOIN `subject` s
ON r.SubjectNo = s.SubjectNo
WHERE SubjectName = '高等英语'
ORDER BY StudentResult DESC-- 方式二:使用子查询(有里及外)
SELECT StudentNo,SubjectNo,StudentResult
FROM result
-- where查看所有高等数学的学号
WHERE SubjectNo = (
SELECT SubjectNo FROM `subject`
WHERE SubjectName = '高等英语'
)
ORDER BY StudentResult DESC-- ============================================-- 查询课程为 高等英语 且 分数不小于80的同学的学号和姓名
SELECT DISTINCT r.StudentNo,StudentName
FROM student s
INNER JOIN result r
ON s.StudentNo = r.StudentNo
INNER JOIN `subject` sub
ON r.SubjectNo = sub.SubjectNo
WHERE StudentResult >=80 AND SubjectName = '高等英语'-- 分数不小于80分的学生的学号和姓名
SELECT DISTINCT s.StudentNo,StudentName
FROM student s
INNER JOIN result r
ON s.StudentNo = r.StudentNo
WHERE StudentResult >=80-- 在这个基础上增加一个科目,高等英语
-- 查询高等英语 的编号
SELECT DISTINCT s.StudentNo,StudentName
FROM student s
INNER JOIN result r
ON s.StudentNo = r.StudentNo
WHERE StudentResult >=80 AND SubjectNo = (
SELECT SubjectNo FROM `subject`
WHERE SubjectName = '高等英语'
)-- 改造(由里及外)
SELECT StudentNo,StudentName FROM student WHERE StudentNo IN (SELECT StudentNo FROM result WHERE StudentResult >=80 AND SubjectNo = (SELECT SubjectNo FROM `subject`WHERE SubjectName = '高等英语'))
分组和过滤
-- 查询不同课程的平均分,最高分,最低分
-- 核心:(根据不同的课程分组)
SELECT SubjectName,AVG(`StudentResult`) AS '平均分',MAX(`StudentResult`) AS '最高分',MIN(`StudentResult`) AS '最低分'
FROM result r
INNER JOIN `subject` sub
ON r.SubjectNo = sub.SubjectNo
GROUP BY r.SubjectNo -- 通过什么字段分组
HAVING 平均分>70
MySQL函数
常用函数
-- ======函数=====-- 数学函数
SELECT ABS(-8) -- 绝对值
SELECT ceiling(9.5) -- 向上取整
SELECT FLOOR(9.5) -- 向下取整
SELECT RAND() -- 返回一个 0~1 之间的随机数
SELECT SIGN(10) -- 判断一个数的符号 0返回0 负数返回-1 正数返回1-- 字符串函数
SELECT CHAR_LENGTH('即使再完美,也会犯错') -- 字符串的长度
SELECT CONCAT('我','爱','你们') -- 拼接字符串
SELECT INSERT('我爱编程',1,2,'超级热爱') -- 查询 从某个位置开始替换某个长度
SELECT LOWER('SGL') -- 转换小写字母
SELECT UPPER('sgl') -- 转换大写字母
SELECT INSTR('sgl','g') -- 返回第一次出现的子串的索引
SELECT REPLACE('坚持就能成功','坚持','努力') -- 替换出现的指定字符串
SELECT SUBSTR('坚持就能成功',1,2) -- 返回指定的子字符串(源字符串,截取的位置,截取的长度)-- 查询姓 施的同学 姓名改为 邹
SELECT * FROM student
WHERE StudentName LIKE '施%'SELECT REPLACE(StudentName,'施','时') FROM student
WHERE StudentName LIKE '施%'-- 时间和日期函数
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 USER()
SELECT VERSION()
聚合函数
函数名称 | 描述 |
---|---|
count() | 计数 |
sum() | 求和 |
avg() | 平均数 |
max() | 最大值 |
min() | 最小值 |
-- =======聚合函数======
-- 都能够统计表中的数据 查询多少个记录,就用countSELECT COUNT(`StudentNo`) FROM student -- count(字段) 会忽略所有的null值
SELECT COUNT(*) FROM student -- count(*) 不会忽略null值 本质:计算行数
SELECT COUNT(1) FROM result -- count(1) 不会忽略null值 本质:计算行数SELECT SUM(`StudentResult`) AS 总和 FROM result
SELECT AVG(`StudentResult`) AS 平均数 FROM result
SELECT MAX(`StudentResult`) AS 最大值 FROM result
SELECT MIN(`StudentResult`)AS 最小值 FROM result
数据库级别的MD5加密(了解即可)
MD5信息摘要算法(英语:MD5 Message-Digest Algorithm),MD5不可逆
-- =====测试MD5加密=====
DROP TABLE textCREATE TABLE `text`(`id` INT(4) NOT NULL,`name` VARCHAR(20) NOT NULL,`pwd` VARCHAR(50) NOT NULL,PRIMARY KEY (`id`))ENGINE=INNODB DEFAULT CHARSET=utf8INSERT INTO text
VALUES(1,'zhangsan','123456'),(2,'lisi','123456'),(3,'wangwu','123456')-- 加密
UPDATE `text` SET pwd=MD5(pwd) WHERE id = 1UPDATE `text` SET pwd=MD5(pwd) -- 加密全部的密码-- 插入的时候加密
INSERT INTO text VALUES(4,'sgl',MD5('123456'))-- 如何校验:将用户传递进来的密码,进行md5加密,然后比对加密后的密码
SELECT * FROM text WHERE `name` = 'sgl' AND pwd=MD5('123456')
事务(重要)
原则:ACID原则 原子性,一致性,隔离性,持久性
- 原子性(Atomicity)
原子性是指事务是一个不可分割的工作单位,事务中的操作要么都发生,要么都不发生。 - 一致性(Consistency)
事务前后数据的完整性必须保持一致。 - 隔离性(Isolation)
事务的隔离性是多个用户并发访问数据库时,数据库为每一个用户开启的事务,不能被其他事务的操作数据所干扰,多个并发事务之间要相互隔离。 - 持久性(Durability)
持久性是指一个事务一旦被提交,它对数据库中数据的改变就是永久性的,接下来即使数据库发生故障也不应该对其有任何影响
隔离导致的一些问题
脏读:指一个事务读取了另外一个事务未提交的数据。
不可重复读:在一个事务内读取表中的某一行数据,多次读取结果不同。
虚读(幻读):是指在一个事务内读取到了别的事务插入的数据,导致前后读取数量总量不一致。
事务原理图(简单描述):
执行事务
-- =========事务=========-- MySQL 是默认开启事务自动提交
SET autocommit = 0 -- 关闭
SET autocommit = 1 -- 开启(默认)-- 手动处理事务
START autocommit = 0 -- 关闭自动提交-- 事务开启 transaction
SET TRANSACTION -- 标记一个事务的开始,从这个开始之后,sql 都在同一个事务内INSERT xx
INSERT xx-- 提交:持久化(成功)
COMMIT
-- 回滚:回到原来的样子 (失败)
ROLLBACK-- 事务结束
SET autocommit = 1 -- 开启自动提交
练习:
-- 转账
-- COLLATE 核对
CREATE DATABASE shop CHARACTER SET utf8 COLLATE utf8_general_ci
USE shop
DROP TABLE account
CREATE TABLE `account` (`id` INT(3) NOT NULL AUTO_INCREMENT,`name` VARCHAR(20) NOT NULL,`money` DECIMAL(9,2) NOT NULL,PRIMARY KEY(`id`))ENGINE=INNODB DEFAULT CHARSET=utf8INSERT INTO `account` (`name`,`money`)
VALUES ('A',2000.00),('B',1000.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加500COMMIT -- 提交事务
ROLLBACK -- 回滚事务SET autocommit = 1 -- 恢复默认值
索引
简述:索引(index)是帮助MySQL高效获取数据的数据结构;索引的本质:索引是数据结构
索引的分类
在一个表中,主键索引只能有一个,唯一索引可以有多个
主键索引(primary key)
- 唯一的标识,主键不可重复,只能有一个列作为主键
唯一索引(unique key)
- 避免出现重复的列,唯一索引可以重复,多个列都可以标识唯一索引
常规索引(key/index)
- 默认的,用key或index设置
全文索引(fulltext)
- 快速定位数据
-- 索引的使用
-- 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 '' COMMENT '用户昵称',
`eamil` 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=utf8 COMMENT='app用户表'DROP TABLE app_user
TRUNCATE `app_user`-- 插入100万条数据
DELIMITER $$ -- 写函数之前必须写
CREATE FUNCTION mock_data()
RETURNS INT
BEGINDECLARE num INT DEFAULT 1000000;DECLARE i INT DEFAULT 0;WHILE i<num DOINSERT INTO app_user(`name`,`eamil`,`phone`,`gender`,`password`,`age`)VALUES(CONCAT('用户',i),'2259567490@qq.com',CONCAT('18',FLOOR(RAND()*((999999999-100000000)+100000000))),FLOOR(RAND()*2),UUID(),FLOOR(RAND()*10));SET i=i+1;END WHILE;RETURN i;END;
SELECT mock_data() -- 执行此函数 生成一百万条数据INSERT INTO app_user(`name`,`eamil`,`phone`,`gender`,`password`,`age`)
VALUES(CONCAT('用户1'),'2259567490@qq.com',CONCAT('18',FLOOR(RAND()*((999999999-100000000)+100000000))),FLOOR(RAND()*2),UUID(),FLOOR(RAND()*100))SELECT * FROM app_user WHERE `name` = '用户99999' -- 0.494秒-- 命名 id_表名_字段名
-- 创建索引的方式:CREATE INDEX 索引名 ON 表名(字段名)
CREATE INDEX id_app_user_name ON app_user(`name`)SELECT * FROM app_user WHERE `name` = '用户99999' -- 0.026秒EXPLAIN SELECT * FROM app_user WHERE `name` = '用户99999'
执行语句:
EXPLAIN 分析sql执行的状况
EXPLAIN SELECT * FROM app_user WHERE `name` = '用户99999'
结果有无索引的区别:
有索引:查询一列
无索引:查询992269列
创建索引的方式:
-- 1.方式一
-- 命名 id_表名_字段名
-- 创建索引的方式:CREATE INDEX 索引名 ON 表名(字段名)
CREATE INDEX id_app_user_name ON app_user(`name`)
-- 1.方式二
-- 添加一个全文索引 (索引名) 列名
ALTER TABLE school.student ADD FULLTEXT INDEX `StudentName`(`StudentName`)
索引原则
- 索引不是越多越好
- 不要对进程变动的数据加索引
- 小数据量的表不需要加索引
- 索引一般加在常用查询的字段上
MySQL索引背后的原则:
连接:CodingLabs
权限管理和备份
用户管理
SQL命令操作
用户表:mysql.user
本质:读这张表进行增删改查
-- 创建用户 CREATE USER 用户名 IDENTIFIED [WITH 插件] BY '密码';
-- CREATE USER 用户名 IDENTIFIED BY '密码';
CREATE USER `kuangshen` IDENTIFIED BY '123456';-- 修改当前用户密码用户密码
SET PASSWORD =PASSWORD('654321')-- 修改指定用户密码
SET PASSWORD FOR `kuangshen` = PASSWORD('654321')-- 重命名 RENAME USER 原来的名字 TO 旧名字
RENAME USER kuangshen TO kuangshen02-- 用户授权 ALL privileges 全部的权限,库,表
-- ALL PRIVILEGES 除了给别人权限,其他都能看
GRANT ALL PRIVILEGES ON *.* TO kuangshen02
GRANT ALTER ON `school`.* TO 'kuangshen02'@'%'
GRANT ALTER ON `school`.`app_user` TO 'kuangshen02'@'%'-- 查询权限
SHOW GRANTS FOR kuangshen02 -- 查看指定用户权限GRANT ALL PRIVILEGES ON *.* TO 'kuangshen02'@'%'-- root用户权限 GRANT ALL PRIVILEGES ON *.* TO 'root'@'localhost' WITH GRANT OPTION
SHOW GRANTS FOR root@localhost -- 撤销权限 REVOKE 哪些权限 ,在哪个库撤销,给谁撤销
REVOKE ALL PRIVILEGES ON *.* FROM kuangshen02
REVOKE ALTER ON `school`.* FROM 'kuangshen02'@'%'
REVOKE ALTER ON `school`.`app_user` FROM 'kuangshen02'@'%'-- 删除用户
DROP USER kuangshen02
DROP USER sgl@127.0.0.1
MySQL备份
作用:保证数据不丢失;数据转移
MySQL数据库备份的方式:
- 直接拷贝物理文件
- 在命令行导出 mysqlump 命令行使用
# mysqldump -h主机 -u用户 -p密码 数据库 表名 >物理磁盘位置\文件名
mysqldump -hlocalhost -uroot -p123456 school student >F:\a.sql
# mysqldump -h主机 -u用户 -p密码 数据库 表名1 表名2 表名2 ... >物理磁盘位置\文件名
mysqldump -hlocalhost -uroot -p123456 school student result >F:\b.sql
# mysqldump -h主机 -u用户 -p密码 数据库 >物理磁盘位置\文件名
mysqldump -hlocalhost -uroot -p123456 school >F:\c.sql# 导入
#登陆的情况下,切换到指定的数据库
# source 备份文件
source F:\a.sql#不登陆,导入
mysql -u用户 -p密码 数据库 <备份文件
- 在Navicat这种可视化工具中手动导出
规范数据库设计
设计数据库的步骤
略略…
三大范式
规范数据库的设计
- 第一范式(1NF)
原子性:保证每一列不可再分
- 第二范式(2NF)
前提:满足第一范式
每张表只描述一件事情
- 第三范式(3NF)
前提:满足第一范式和第二范式
第三范式需要确保数据表中的每一列数据都和主键直接相关,而不能间接相关
规范性和性能的问题
略略…想了解再自己查询
JDBC(***)
数据库驱动
程序通过 数据库驱动,和数据库打交道
JDBC
Java数据库连接,(Java Database Connectivity,简称JDBC)是Java语言中用来规范客户端程序如何来访问数据库的应用程序接口,提供了诸如查询和更新数据库中数据的方法。JDBC也是Sun Microsystems的商标。我们通常说的JDBC是面向关系型数据库的。
连接方式
各种数据库使用JDBC连接的方式:
⒈Oracle8/8i/9i数据库(thin模式)
⒉DB2数据库
⒊Sql Server7.0/2000数据库
⒋Sybase数据库
⒌Informix数据库
⒍MySQL数据库
⒎PostgreSQL数据库
⒏access数据库直连用ODBC的
当访问一个远程数据库时,JDBC将利用Internet文件的编址方案和一个看起来很像网页地址(统一资源定位器URL)的文件名。
JDBC为程序员指定了一组在编写SQL请求时使用的面向对象的类。还有一组附加的类描述了JDBC驱动API。能映射成Java数据类型的最普通的SQL数据类型都是支持的。这个API提供了微软事务服务器请求的执行支持以及提交和回滚到事务开始的能力。
主要用途
与数据库建立连接
发送 SQL 语句
处理结果
建立连接
建立连接的五大步骤:
1加载(注册)数据库
2 建立链接
3 执行SQL语句
4 处理结果集
5 关闭数据库
JDBC程序
创建测试数据库
CREATE DATABASE jdbcStudy CHARACTER SET utf8 COLLATE utf8_general_ci;USE jdbcStudyCREATE 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,'zhangsan','123456','zs@sina.com','2001-05-26'),(2,'lisi','123456','lisi@sina.com','2001-09-16'),(3,'wangwu','123456','ww@sina.com','2000-08-26')
创建一个普通的项目
导入数据库驱动
maven仓库下载mysql-connector-java-5.1.47.jar
创建一个lib目录,将 mysql-connector-java-5.1.47.jar
导入(粘贴复制即可),导入后:右键lib,点击Add as Library…
- 编写测试代码
package com.sgl.lession01;import java.sql.*;public class JdbcFirstDemo {public static void main(String[] args) throws ClassNotFoundException, SQLException {//1.加载/注册数据库驱动Class.forName("com.mysql.jdbc.Driver"); //固定写法,加载驱动//用户信息和urlString url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=false";String username = "root";String password = "123456";//2.通过DriverManager获取数据库来连接 Connection 代表数据库Connection connection = DriverManager.getConnection(url, username, password);//3.Connection对象获取Statement对象Statement statement = connection.createStatement();//4.使用statement执行sql语句String sql = "SELECT * FROM users";ResultSet resultSet = statement.executeQuery(sql);//返回的结果集,结果集中封装了我们全部的查询结果//5.操作ResultSet结果集while (resultSet.next()){System.out.println("id="+resultSet.getObject("id")+"|"+"name="+resultSet.getObject("NAME")+"|"+"pwd="+resultSet.getObject("PASSWORD")+"|"+"email="+resultSet.getObject("email")+"|"+"birthday="+resultSet.getObject("birthday"));}//6.释放连接resultSet.close();statement.close();connection.close();}
}
允许结果:
步骤总结:
- 加载并注册数据库驱动 DriverManager
Class.forName("com.mysql.jdbc.Driver"); //建议使用
或
DriverManager.registerDriver(new com.mysql.jdbc.Driver());
- 通过DriverManager获取数据库来连接 Connection 代表数据库:数据库设置自动提交,事务提交,事务回滚
Connection connection = DriverManager.getConnection(url, username, password);
Connection 代表数据库:数据库设置自动提交,事务提交,事务回滚
connection.setAutoCommit();//自动提交
connection.commit();//事务提交
connection.rollback();//事务回滚
- Connection对象获取Statement对象
Statement statement = connection.createStatement();
- 使用statement执行sql语句
ResultSet resultSet = statement.executeQuery(sql)
- 操作ResultSet结果集
获得指定的数据类型
resultSet.getObject() //在不知道列类型的情况下使用//如果知道列的类型就使用指定的类型
resultSet.getString();
resultSet.getInt();
resultSet.getFloat();
resultSet.getDate();
resultSet.getObject();
while (resultSet.next()){System.out.println("id="+resultSet.getObject("id")+"|"+"name="+resultSet.getObject("NAME")+"|"+"pwd="+resultSet.getObject("PASSWORD")+"|"+"email="+resultSet.getObject("email")+"|"+"birthday="+resultSet.getObject("birthday"));}
遍历:
resultSet.beforeFirst(); //移动到最前面
resultSet.afterLast(); //移动到最后面
resultSet.next(); //移动到下一个数据
resultSet.previous(); //移动到前一行
resultSet.absolute(int row); //移动到指定行
- 关闭连接,释放资源
resultSet.close();
statement.close();
connection.close();
- URl
String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=false";
//协议(jdbc:mysql)://主机名(localhost):端口号(3306)/数据库名(jdbcstudy)?固定格式(useUnicode=true&characterEncoding=utf8&useSSL=false) 连接数据库的地址
String username = "root"; // 登录数据库的用户名
String password = "123456";//登录数据库的密码String sql = "SELECT * FROM users";//数据库的查询语句
Statement对象
jdbc中的statement对象用于向数据库发送SQL语句,想要完成对数据库的增删改查,只需要通过这个对象向数据库发送增删改查语句即可
statement对象的executeUpdate方法
,用于向数据库发送增删改的sql语句,executeUpdate执行完后,将会返回一个整数(即增删改语句导致了数据库几行数据发送了变化)
statement.executeQuery()方法用于向数据库发送查询的sql语句,executeQuery方法返回代表查询结果的ResultSet对象
CURD操作-create
使用executeUpdate(String sql)方法完成数据库添加操作
statement st = conn.createStatement();
String sql ="insert into users(...) values(...)";
int num = st.executeUpdate(sql);
if (num>0){System.out.println("插入成功");
}
CRUD操作-delete
使用executeUpdate(String sql)方法完成数据库删除操作
statement st = conn.createStatement();
String sql ="delete from users where id=1";
int num = st.executeUpdate(sql);
if (num>0){System.out.println("删除成功");
}
CRUD操作-update
使用executeUpdate(String sql)方法完成数据库修改操作
statement st = conn.createStatement();
String sql ="update users set name='' where name=''";
int num = st.executeUpdate(sql);
if (num>0){System.out.println("修改成功");
}
CRUD操作-read
使用executeQuery(String sql)方法完成数据库查询操作
statement st = conn.createStatement();
String sql ="select * from users where id=1";
ResultSet rs = st.executeQuery(sql);
while (rs.next()){//根据获取的数据类型,分别调用rs的相应方法映射到Java对象中
}
具体代码:
增删改的方法都是executeUpdate
配置文件db.properties
driver = com.mysql.jdbc.Driver
url = jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=false
username = root
password = 123456
定义一个JdbcUtils类
package com.sgl.lession02.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 {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.驱动只加载一次try {Class.forName(driver);} catch (ClassNotFoundException e) {e.printStackTrace();}} catch (IOException 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 throwables) {throwables.printStackTrace();}}if (statement!=null){try {statement.close();} catch (SQLException throwables) {throwables.printStackTrace();}}if (connection!=null){try {connection.close();} catch (SQLException throwables) {throwables.printStackTrace();}}}
}
插入:
package com.sgl.lession02;import com.sgl.lession02.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 {connection = JdbcUtils.getConnection(); //.通过DriverManager获取数据库来连接 Connection 代表数据库statement = connection.createStatement();//Connection对象获取Statement对象String sql = "INSERT INTO users(`id`,`NAME`,`PASSWORD`,`email`,`birthday`)\n" +"VALUES(4,'sgl','123456','2256955@qq.com','2000-08-26')"; //使用statement执行sql语句int i = statement.executeUpdate(sql);if (i>0){System.out.println("插入成功");}} catch (SQLException throwables) {throwables.printStackTrace();}finally {JdbcUtils.release(connection,statement, null);}}/*重复插入会报错:id为主键Duplicate entry '4' for key 'PRIMARY'*/
}
删除:
package com.sgl.lession02;import com.sgl.lession02.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 {connection = JdbcUtils.getConnection(); //.通过DriverManager获取数据库来连接 Connection 代表数据库statement = connection.createStatement();//Connection对象获取Statement对象String sql = "DELETE FROM users WHERE id=4"; //使用statement执行sql语句int i = statement.executeUpdate(sql);if (i>0){System.out.println("删除成功");}} catch (SQLException throwables) {throwables.printStackTrace();}finally {JdbcUtils.release(connection,statement, null);}}
}
修改:
package com.sgl.lession02;import com.sgl.lession02.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 {connection = JdbcUtils.getConnection(); //.通过DriverManager获取数据库来连接 Connection 代表数据库statement = connection.createStatement();//Connection对象获取Statement对象String sql = "UPDATE users SET `NAME`='sgl' WHERE id=1"; //使用statement执行sql语句int i = statement.executeUpdate(sql);if (i>0){System.out.println("修改成功");}} catch (SQLException throwables) {throwables.printStackTrace();}finally {JdbcUtils.release(connection,statement, null);}}
}
查询:
使用的executeQuery
package com.sgl.lession02;import com.sgl.lession02.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 {connection = JdbcUtils.getConnection();statement = connection.createStatement();String sql = "select * from users where id =1";resultSet = statement.executeQuery(sql);while (resultSet.next()){System.out.println(resultSet.getString("NAME"));}} catch (SQLException throwables) {throwables.printStackTrace();}finally {JdbcUtils.release(connection,statement,resultSet);}}
}
SQL注入问题
sql存在漏洞,会被攻击导致数据泄露 SQL会被拼接
SQL注入即是指web应用程序对用户输入数据的合法性没有判断或过滤不严,攻击者可以在web应用程序中事先定义好的查询语句的结尾上添加额外的SQL语句,在管理员不知情的情况下实现非法操作,以此来实现欺骗数据库服务器执行非授权的任意查询,从而进一步得到相应的数据信息。
SQL注入百度百科
https://baike.baidu.com/item/sql%E6%B3%A8%E5%85%A5/150289?fr=aladdin
package com.sgl.lession02;import com.sgl.lession02.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("'or'1=1","'or'1=1");}//登录业务public static void login(String username,String password){Connection connection =null;Statement statement=null;ResultSet resultSet =null;try {connection = JdbcUtils.getConnection();statement = connection.createStatement();//SELECT * FROM users WHERE `NAME`='sgl' AND `PASSWORD`='123456'//SELECT * FROM users WHERE `NAME`=''or'1=1' AND `PASSWORD`=''or'1=1'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"));System.out.println("==============");}} catch (SQLException throwables) {throwables.printStackTrace();}finally {JdbcUtils.release(connection,statement,resultSet);}}
}
PreparedStatement对象
PreparedStatement可以防止SQL注入,效率更好!
- 插入
package com.sgl.lession02;import com.sgl.lession02.utils.JdbcUtils;
import java.util.Date;
import java.sql.*;public class TestInsert02 {public static void main(String[] args) {Connection connection = null;PreparedStatement preparedStatement =null;ResultSet resultSet = null;try {connection = JdbcUtils.getConnection();//区别// 使用? 占位符代替参数String sql = "INSERT INTO users(`id`,`NAME`,`PASSWORD`,`email`,`birthday`) values(?,?,?,?,?)";preparedStatement = connection.prepareStatement(sql);//预编译SQL,先写sql,然后不执行//手动给参数赋值preparedStatement.setInt(1,4);preparedStatement.setString(2,"sgl");preparedStatement.setString(3,"123321");preparedStatement.setString(4,"2259567490@qq.com");//sql.Date 数据库 java.sql.Date()//util.Date Java new Date().getTime() 获得时间戳preparedStatement.setDate(5,new java.sql.Date(new Date().getTime()));//执行int i = preparedStatement.executeUpdate();if (i>0){System.out.println("插入成功");}} catch (SQLException throwables) {throwables.printStackTrace();}finally {JdbcUtils.release(connection,preparedStatement,null);}}
}
- 删除
package com.sgl.lession02;import com.sgl.lession02.utils.JdbcUtils;import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;public class TestDelete02 {public static void main(String[] args) {Connection connection = null;PreparedStatement preparedStatement =null;ResultSet resultSet = null;try {connection = JdbcUtils.getConnection();//区别// 使用? 占位符代替参数String sql = "DELETE FROM users WHERE id=?";preparedStatement = connection.prepareStatement(sql);//预编译SQL,先写sql,然后不执行//手动给参数赋值preparedStatement.setInt(1,4);//执行int i = preparedStatement.executeUpdate();if (i>0){System.out.println("删除成功");}} catch (SQLException throwables) {throwables.printStackTrace();}finally {JdbcUtils.release(connection,preparedStatement,null);}}
}
- 更新
package com.sgl.lession02;import com.sgl.lession02.utils.JdbcUtils;import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;public class TestUpdate02 {public static void main(String[] args) {Connection connection = null;PreparedStatement preparedStatement =null;ResultSet resultSet = null;try {connection = JdbcUtils.getConnection();//区别// 使用? 占位符代替参数String sql = "UPDATE users SET `NAME`=? WHERE id=?";preparedStatement = connection.prepareStatement(sql);//预编译SQL,先写sql,然后不执行//手动给参数赋值preparedStatement.setString(1,"coco");preparedStatement.setInt(2,1);//执行int i = preparedStatement.executeUpdate();if (i>0){System.out.println("修改成功");}} catch (SQLException throwables) {throwables.printStackTrace();}finally {JdbcUtils.release(connection,preparedStatement,null);}}
}
- 查询
package com.sgl.lession02;import com.sgl.lession02.utils.JdbcUtils;import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;public class TestSelect02 {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=?";preparedStatement = connection.prepareStatement(sql);//预编译SQL,先写sql,然后不执行//手动给参数赋值preparedStatement.setInt(1,1);//传入参数//执行resultSet = preparedStatement.executeQuery();if (resultSet.next()){System.out.println(resultSet.getObject("NAME"));}} catch (SQLException throwables) {throwables.printStackTrace();}finally {JdbcUtils.release(connection,preparedStatement,resultSet);}}
}
SQL注入问题
package com.sgl.lession02;
import com.sgl.lession02.utils.JdbcUtils;import java.sql.*;public class SQL02 {public static void main(String[] args) {login("coco","123456");//login("'or'1=1","'or'1=1"); //运行没有结果,PreparedStatement防止SQL注入问题}//登录业务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"));System.out.println("=========");}} catch (SQLException throwables) {throwables.printStackTrace();}finally {JdbcUtils.release(connection,preparedStatement,resultSet);}}
}
MySQL基础知识(配合Navicat使用)相关推荐
- MySQL工作中的实际用_总结工作中经常用到的mysql基础知识
总结工作中经常用到的mysql基础知识 发布时间:2020-06-08 11:27:30 来源:51CTO 阅读:217 作者:三月 本文主要给大家介绍工作中经常用到的mysql基础知识,文章内容都是 ...
- mysql基础知识(二)
这一篇是第二部分,要查看第一部分,请查看这个链接 mysql基础知识(一) DQL语言 1.1简单的单表查询 查询表的通用格式:select [distinct] [*] [列名1,列名] from ...
- mysql基础知识(一)
mysql是主流的关系型数据库管理系统(RDBMS---relation database management system),操作是需要用SQL(Structured Query Language ...
- MySQL基础知识-MySQL概述安装,单表增删改查,函数,约束,多表查询,事物
MySQL基础知识-MySQL概述安装,单表增删改查,函数,约束,多表查询,事物 前言 1.MySQL概述 1.1数据库相关概念 1.2MySQL数据库 1.2.1版本 1.2.2下载 1.2.3安装 ...
- 【MySQL基础知识】查询、过滤数据关键字
MySQL基础知识 一.检索数据 1. SELECT select是使用最广泛的检索数据的语句. 检索要查的表的所有列: select * from (表名称)... 检索要查的表的某一列或多列: s ...
- 快速学习mysql_快速学习MySQL基础知识
这篇文章主要梳理了 SQL 的基础用法,会涉及到以下方面内容: SQL大小写的规范 数据库的类型以及适用场景 SELECT 的执行过程 WHERE 使用规范 MySQL 中常见函数 子查询分类 如何选 ...
- MySQL基础知识之增删改查
MySQL基础知识之增删改查 MySQL基本语法: 1.创建库:create database 库名: 创建带编码格式的库:create database 库名 character set 编码格式: ...
- linux增删查改语句,mysql基础知识之增删查改使用介绍
mysql基础知识之增删查改使用介绍 本文主要介绍mysql常用的SELECT.INSERT.UPDATE.DELETE语句的使用,数据库的安装这里不做介绍,并且事先已经准备好相关数据. 本文中使用的 ...
- MySql基础知识【一】
Mysql基础知识 1. MySql是什么 2. 数据库设计的三大范式 2.1. 第一范式 2.2. 第二范式 2.3. 第三范式 3. Binlog的三种模式 3.1 Statement模式(默认) ...
- 2.MySQL 基础知识
文章目录 MySQL 基础知识 知识点一 : MySQL命令行常用命令 知识点二 : 持久化 相关概念 知识点三 : 数据库 相关概念 知识点四 : DB 和 DBMS 关系图示 知识点五 : MyS ...
最新文章
- 基于 CoreText 实现的高性能 UITableView
- 2021-01-22 使用 Docker 打包 Python 项目
- bigquery 教程_bigquery挑战实验室教程从数据中获取见解
- 一文读懂 | 进程怎么绑定 CPU
- CentOS7 内核参数优化
- python基础: 选择语句
- python gdal帮助文档
- alot英文怎么读_iot中文读什么,AloT怎么读,Iot是什么意思中文翻译
- winhex数据恢复教程
- 【python+selenium】保留浏览器的自定义设置,不恢复浏览器默认设置
- exce中让两列数据一一对应_excel表格中两组数据如何对应匹配-EXCEL让两个表格中的两列数据一一对应...
- Android Property
- win10备份为wim_玩转一键自动还原,强大你的win10系统
- 2021腾讯前端笔试实习生
- vtkPolyData获取bounds点坐标
- java switch case null_如何在switch中使用null
- 爬虫问题小记 --- UnicodeEncodeError: 'gbk' codec can't encode character '\xa9' in position 25703: illegal
- 函数 fseek() 使用说明
- base64编码解码方法
- 怎么批量提取图片的文件名?
热门文章
- 【LeetCode】726. Number of Atoms 解题报告(Python)
- 基于python的空气质量预测分析可视化系统
- 外汇为什么总是亏损?
- 一款小程序将图片文字单独提取,真的很方便
- ubuntu(18.04)中架设HiGlass docker镜像服务,已尝试mcool、bedpe、wig格式文件
- 中企海外周报 | 青云海外首站布局印尼雅加达;吉利在马来西亚推出本地组装宝腾车型...
- 关于青少年学习演讲与口才对未来的领导力的塑造的探析
- 第13届景驰-埃森哲杯广东工业大学ACM程序设计大赛 D-psd面试(区间dp)
- RTKLIB学习笔记——rtkcmn.c(矩阵及向量运算一)
- Git 笔记 - git branch