MySQL

1、初识MySQL

JavaEE: 企业级]ava开发Web前端（(页面:展示，数据!)
后台（(连接点:连接数据库JDBC，链接前端(控制，控制视图跳转，和给前端传递数据))数据库(存数据，Txt，Excel,word)
只会写代码，学好数据库，基本混饭吃!
操作系统，数据结构与算法!当一个不错的程序猿!
离散数学，数字电路，体系结构，编译原理。＋实战经验，高级程序猿_{优秀的程序猿}

1.1、为什么学习数据库

1、岗位需求
2、现在的世界，大数据时代~，得数据库者得天下。3、被迫需求:存数据
4、数据库是所有软件体系中最核心的存在DBA

1.2、什么是数据库

数据库(DB，DataBase)
概念:数据仓库，软件，安装在操作系统(window ,linux, mac、…)之上! SQL，可以存储大量的数据。500万!
作用:存储数据，管理数据

1.3、数据库分类

关系型数据库:(SQL)
. MySQL,Oracle，sql Server,DB2,SQLlite
·通过表和表之间，行和列之间的关系进行数据的存储，学员信息表，考勤表，…….
非关系型数据库:(NoSQL) Not Only
. Redis，MongDB
·非关系型数据库，对象存储，通过对象的自身的属性来决定。
DBMS(数据库管理系统)
·数据库的管理软件，科学有效的管理我们的数据。维护和获取数据;
l
. MySQL

1.4、MySQL简介

MySQL是一个关系型数据库管理系统前世:瑞典MySQL AB公司
今生:属于Oracle旗下产品
MySQL是最好的RDBMS (Relational Database Management System，关系数据库管理系统)应用软件之一。开软的数据库软件~
体积小、速度快、总体拥有成本低，招人成本比较低，所有人必须会~中小型网站、或者大型网站，集群!
官网:https://www.mysql.com

官网下载地址:https://dev.mysql.com/downloads/mysqL
安装建议∶
1、尽量不要使用exe，注册表2、尽可能使用压缩包安装~

1.5.安装MySQL

1、解压
2、把这个包放到自己的电脑环境目录下~
3、配置环境变量
4、新建mysql配置文件ini
1 [mysqld]
2#目录一定要换成自己的
3basedir=D : \Environment\mysq1-5.7.19\
4datadir=D : \Environment\mysq1-5.7.19\data\5 port=3306
6skip-grant-tables
5、启动管理员模式下的CMD，运行所有的命令6、安装mysql服务
7、初始化数据库文件
8、启动mysql，进去修改密码~
9、进入mysql通过命令行（-p后面不要加空壳)，修改密码(sql语句后面一定要加分号! )10、注掉ini中的跳过密码
11、重启mysql。连接测试，如果连接成功就OK了!

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dD6Q1B23-1612504405404)(C:\Users\whl151885\AppData\Roaming\Typora\typora-user-images\image-20210125113710637.png)]

1.6安装SQLyog

官网下载

1.7.连接数据库

mysql -uroot -p123456--连接数掂车
update mysq1.user set authentication_string=password('123456') where user='root' and Host ='localhost '; --修改用户密码
flush privileges; --刷新权限
--所有的语句都使用;结尾

----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

show databases;--查看所有的数据库
mysq1> use school --切换数据库use数据库名Database changed
show tables; --查看数据库中所有的表
describe student; --显示数据库中所有的表的信息
create database westos; --创建一个数据库
exit;--退出连接
--单行注释（SQL的本来的注释)*(sq1的多行注释)
he17oi
asdasdasdas*/

2.操作数据库

2.1、操作数据库(了解)

1、创建数据库
CREATE DATABASE [IF NOT EXISTS] westos;
2、删除数据库
DROP DATABASE [IF EXTSTS] westos
3、使用数据库
1 – tab键的上面,如果你的表名或者字段名是一个特殊字符，就需要带

usE school
4、查看数据库
SHOw DATABASES --查看所有的数据库
对比: SQLyog的可视化操作

学习思路:
·对照sqlyog可视化历史记录查看sql

·固定的语法或关键字必须要强行记住!

2.2数据库的列类型

数值
. tinyint 十分小的数据 1个字节.

smallint 较小的数据 2个字节

mediumint 中等大小的数据 3个字节.

int 标准的整数 4个字节 常用的int
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进行运算，结果为NULL

2.3、数据库的字段属性(重点)

Unsigned : 无符号的整数 声明了该列不能声明为负数
zerofill : 0填充的 不足的位数，使用O来填充，int (3) , 5 — 005
自增:
●通常理解为自增，自动在上一条记录的基础上＋1(默认)

●通常用来设计唯一的主键~index，必须是整数类型
可以自定义设计主键自增的起始值和步长

非空NUll not null
·假设设置为not null ，如果不给它赋值，就会报错!.NUll，如果不填写值，默认就是null !
默认:
●设置默认的值!
. sex，默认值为男，如果不指定该列的值，则会有默认的值

拓展:听听就好
1每一个表，都必须存在以下五个字段!未来做项目用的，表示一个记录存在意义!2
3 id主键
4’version`乐观锁

5 is_delete伪删除

6 gmt_create创建时间

7 gmt_update修改时间

2.4创建数据库表(重点)

/*
–目标:创建一个schoo1数据库
–创建学生表(列,字段)使用sQL创建
–学号int登录密码varchar(20）姓名,性别varchar(2),出生日期(datatime),家庭住址, emai7
–注意点，使用英文()，表的名称和字段尽量使用`括起来
– AUTO_INCREMENT自增
–字符串使用单引号括起来!
–所有的语句后面加，(英文的），最后一个不用加-- PR工MARY KEY主键，一般一个表只有一个唯一的主键!
*/

CREATE TABLE `student`(
`id` INT(3) NOT NULL COMMENT'学号',
`name` VARCHAR(10) NOT NULL DEFAULT'匿名' COMMENT'姓名',
`sex` VARCHAR(2) DEFAULT'男' COMMENT'性别',
#`birthday` data(10) comment'出生日期',
`address` VARCHAR(10) COMMENT'家庭住址',
`email` VARCHAR(10) COMMENT'邮箱',
PRIMARY KEY(`id`)
)ENGINE=INNODB DEFAULT CHARSET=utf8

格式

CREATE TABLE [IFNOT EXISTS]`表名`(
'字段名’列类型[属性][索引][注释]，
..........
'字段名’列类型[属性][索引][注释]，
'字段名'列类型[属性][索引][注释])[表类型][字符集设置][注释]

常用命令

1 sHow CREATE DATABASE school --查看创建数据库的语句

2 SHow CREATE TABLE student --查看student数据表的定义语句

3 DESc student --显示表的结构

2.5数据表的类型

1 --关于数据库引擎2/*
3INNODB 默认使用~

4MYISAM早些年使用的5*/

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

常规使用操作:
. MYISAM 节约空间，速度较快
INNODB 安全性高，事务的处理，多表多用户操作

在物理空间存在的位置
所有的数据库文件都存在data目录下，一个文件夹就对应一个数据库本质还是文件的存储!
MySQL引擎在物理文件上的区别
. InnoDB在数据库表中只有一个

**.frm 文件，以及上级目录下的ibdata1文件*

**. MYISAM对应文件*
*.frm表结构的定义文件。.*

*MYD数据文件(data)。*

**.MYI索引文件(index)*

设置数据库表的字符集编码
1CFARSET=utf8
不设置的话，会是mysql默认的字符集编码~(不支持中文! )MySQL的默认编码是Latin1，不支持中文
在my.ini 中配置默认的编码

1 character-set-server=utf8

2.6、修改删除表

修改

1--修改表名:ALTER TABLE旧表名 RENAMEAS新表名
2ALTER TABLE teacher RENAME AS teacher1
3--增加表的字段: ALTER TABLE表名ADD字段名列属性
4ALTER TABLE teacher1 ADD age INT(11)
5
6
--修改表的字段(重命名，修改约束!)
7-- ALTERTABLE表名MODIFY 字段名列属性门
8ALTER TABLE teacher1 MODIFY age VARCHAR(11)--修改约束
9-- ALTERTABLE表名CHANGE旧名字新名字列属性[门
10ALTER TABLE teacher1 CHANGE age age1 INT(1)--字段重名名
11
12
13--删除表的字段:ALTER TABLE表名 DROP字段名
14 ALTER TABLE teacher1 DROP age1

删除
--删除表（如果表存在再删除）
DROP TABLE IF EXISTS teacher1
所有的创建和删除操作尽量加上判断，以免报错~
注意点:
。字段名，使用这个包裹!·注释 --/**/
. sql关键字大小写不敏感，建议大家写小写I·所有的符号全部用英文

3.MySQL数据管理

3.1外键(了解即可)

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

I
–学生表的 gradeid字段要去引用年级表的gradeid8
–定义外键key
–给这个外键添加约束(执行引用)references引用10

CREATE TABLE ^grade (
gradeid` INT(10) NOT NULL AUTO_INCREMENT COMMENT '年级id '，'gradename`VARCHAR(50)NOT NULL COMMENT '年级名称'，
PRIMARY KEY ( gradeid )
)ENGINE=工NNODB DEFAULT CHARSET=utf8

–学生表的 gradeid字段要去引用年级表的gradeid8
–定义外键key
–给这个外键添加约束(执行引用)references引用10

CREATE TABLE IF NOT EXISTs `studentT (
`id` INT(4)NOT NULL AUTO_INCREMENT COMMENT '学号'，

'nameVARCHAR(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(50)NOT NULL COMMENT ‘年级名称'，

PRIMARY KEY ( gradeid )
)ENGINE=INNODB DEFAULT CHARSET=utf86

–学生表的gradeid 字段要去引用年级表的gradeid–定义外键key
–给这个外键添加约束(执行引用）references引用

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 '出生日期'，gradeid INT(10)NOT NULL COMMENT'学生的年级'，
address` VARCHAR(100) DEFAULT NULL COMMENT '家庭住址'，emai7` VARCHAR(50) DEFAULT NULL COMMENT '邮箱'，
PRIMARY KEY( id )
)ENGINE=INNODB DEFAULT CHARSET=utf8
--创建表的时候没有外键关系
ALTER TABLE `student
ADD CONSTRAINT‘FK_gradeid` FOREIGN KEY( gradeid ) REFERENCES ‘grade ` ( gradeid );
-- ALTER TABLE表 ADD CONSTRAINT约束名FOREIGN KEY(作为外键的列)REFERENCES那个表(哪个字段)

3.2DML语言(全部掌握)

3.3添加

insert
1–插入语句（添加)
2 – Insert into表名([字段名1,字段2,字段3])values(‘值1’),(‘值2’),(‘值3’，…)3工NSERT INTO ^grade (gradename ) VALUES(‘大四’)
4
–由于主键自增我们可以省略(如果不写表的字段，他就会—一匹配)6工NSERT INTo 'grade VALUES(‘大三’)
8
–一般写插入语句，我们一定要数据和字段一一对应!9
10
–插入多个字段11

INSERT INTO 'grade `( gradename ')
VALUES('大二'),('大一')
INSERT INTo `student`( name `) VALUES ('张三')
INSERT INTo ‘student ( name', 'pwd , sex ) VALUES ('张三' , 'aaaaaa','男')
INSERT INTo 'student` ( name', pwd ` , 'sex )
20VALUES ('李四', 'aaaaaa ','男'),('王五', 'aaaaaa','男'）

语法:insert into表名([字段名1,，字段2，字段3])values(‘值1’),(‘值2’)，(‘值3’，…)
注意事项:
1.字段和字段之间使用英文逗号隔开
2.字段是可以省略的，但是后面的值必须要要——对应，不能少3.可以同时插入多条数据，VALUES后面的值，需要使用，隔开即可
values (),(),…

3.4修改

update修改谁﹐(条件)set原来的值=新值
1–修改学员名字,带了简介

2UPDATE `student` SET name `='周洁’WHERE id = l;3
--不指定条件的情况下，会改动所有表!
UPDATE `student`sET name ='hhh'

–修改多个属性,逗号隔开8

UPDATE‘student’ SET name='rrrr'，email ='24736743@qq.com 'WHERE id = l;9
10

– 语法:
11 – UPDATE表名 set co7num_name = value,[co1num_name = value,. . . .] where[条件条件: where

-- 语法:
11 -- UPDATE表名 set co7num_name = value,[co1num_name = value,. . . .] where[条件条件: where

```sql
UPDATE‘student’ SET name='rrrr'，email ='24736743@qq.com 'WHERE id = l;9
10
```

-- 语法:
11 -- UPDATE表名 set co7num_name = value,[co1num_name = value,. . . .] where[条件条件: where

条件: where子句运算符id等于某个值，大于某个值，在某个区间内修改…操作符会返回布尔值

	操作符	含义	范围	结果
	=	等于	5=6	false
	<>或!=	不等于	5<>6	true
	<
	<=
	>
	>=
	BETWEEN … and …	在某个范围内	[2,5]
	AND	我和你&&	5>1 and 1>2	false
	OR	我或你	5>1 or 1>2	true

1–通过多个条件定位数据
2UPDATEstudent SET name '='长江7号’ WHERE name '=‘狂神44’ AND sex=‘女’

·条件，筛选的条件，如果没有指定，则会修改所有的列. value，是一个具体的值，也可以是一个变量
·多个设置的属性之间，使用英文逗号隔开
I

语法:`UPDATE表名 set colnum_name = value,[co 1num name = value,.....] where[条件]注意:
. colnum_name是数据库的列，尽量带上`

·条件，筛选的条件，如果没有指定，则会修改所有的列. value，是一个具体的值，也可以是一个变量
·多个设置的属性之间，使用英文逗号隔开
I

·条件，筛选的条件，如果没有指定，则会修改所有的列. value，是一个具体的值，也可以是一个变量
·多个设置的属性之间，使用英文逗号隔开
I

1--通过多个条件定位数据
2UPDATE`student` SET name '='长江7号’ WHERE name '='狂神44' AND sex='女'
语法:`UPDATE表名 set colnum_name = value,[co 1num name = value,.....] where[条件]注意:
. colnum_name是数据库的列，尽量带上`

·条件，筛选的条件，如果没有指定，则会修改所有的列. value，是一个具体的值，也可以是一个变量
·多个设置的属性之间，使用英文逗号隔开
I

1UPDATE`studenti sET birthday'= CURRENT_T工ME WHERE ‘name'='长江7号’AND sex='女'

3.5删除

delete命令
语法: delete from表名[where条件]

--删除数据(避免这样写，会全部删除)
DELETE FROM`student'
--删除指定数据
DELETE FROMstudent`WHERE id = 1;

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

--清空student表
TRUNCATE 'student
delete的 TRUNCATE 区别
·相同点:都能删除数据，都不会删除表结构·不同:
TRUNCATE 重新设置自增列计数器会归零oTRUNCATE不会影响事务

--测试delete和TRUNCATE区别

CREATE TABLE`test (
`id INT(4)NOT NULL AUTO_INCREMENT,
`coul` VARCHAR(20) NOT NULL,
PRIMARY KEY ( id)
)ENGINE=INNODB DEFAULT CHARSET=utf8
INSERT INTO 'test ( co17 ) VALUES( '1'),('2 '),( '3')
DELETE FROMtest --不会影响自增
TRUNCATE TABLE test --自增会归零

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

. InnoDB 自增列会重1开始(存在内存当中的，断电即失).

MylSAM继续从上一个自增量开始(存在文件中的，不会丢失)

4、DQL查询数据(最重点)

4.1、DQL

(Data Query LANGUAGE∶数据查询语言)·所有的查询操作都用它 Select·简单的查询，复杂的查询它都能做~数据库中最核心的语言，最重要的语句·使用频率最高的语句

4.2、指定查询字段

语法:SELECT字段，… FROM表
有的时候，列名字不是那么的见名知意。我们起别名 AS字段名as 别名表名 as 别名

--查询全部的学生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 别名

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

 --查询一下有哪些同学参加了考试，成绩
SELECT *FROM result --查询全部的考试成绩
SELECT `studentNo`FROM result --查询有哪些同学参加了考试
SELECT DISTINCT 'studentNol FROM resu1t --发现重复数据，去重*

数据库的列(表达式)

SELECT VERSION(--查询系统版本（函数)
SELECT 100*3-1 AS 计算结果--用来计算（表达式)
SELECT @auto_increment_increment --查询自增的步长(变量)
--学员考试成绩＋1分查看
SELECT ‘studentNo', 'studentResult `+1 AS '提分后’FROM result

数据库中的表达式:文本值，列，Null，函数，计算表达式，系统变量…select表达式from表

4.3、where条件子句

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

搜索的条件由一个或者多个表达式组成!结果布尔值

逻辑运算符

运算符	语法	描述
and &&	a and b a&&b	逻辑与，两个都为真，结果为真
or ll	a or b a| | b	逻辑或，其中一个为真，则结果为真
Not !	not a ! a	逻辑非，真为假，假为真!

尽量使用英文字母

--=======where ==
SELECT studentNo,'studentResult` FROM result
--查询考试成绩在95~100分之间
SELECT studentNo, 'studentResult` FROM resultWHERE StudentResult>=95 AND StudentResu1t<=100
-- and&&
SELECT studentNo， 'studentResult`FROMresult
WHERE StudentResult>=95 && StudentResult<=100
--模糊查询（区间)
SELECT studentNo, 'studentResult`FROM result
WHERE StudentResult BETWEEN 95 AND 100
--除了1000号学生之外的同学的成绩
SELECT studentNo， 'studentResult`FROM result
WHERE studentNo!=1000;

-- !=not
 SELECT studentNo, 'studentResult` FROM result
 WHERE NOT studentNo = 1000
 
 
 

--====================WHERE=================================

SHOW DATABASES

USE school

SHOW TABLES

DESCRIBE student

SELECT `id` FROM student

INSERT INTO `student` (`id`,`name`,`sex`,`address`,`email`) 
VALUES ('8','王海林','男','杭州','000000'),('9','洁','男','杭州','1111')


SELECT `id`,`name` FROM student
WHERE `id`=7 OR `id`=8

模糊查询:比较运算符

运算符	语法	描述
IS NULL	a is null	如果操作符为NUI,结果为真
IS NOT NULL	a is not null	如果操作符不为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…其中的某一个值中，结果为真

• --=====模糊查询====
  --查询姓刘的同学
  -- 7ike结合%(代表0到任意个字符)_(一个字符)SELECT `studentNo , 'studentName` FROM studentWHERE StudentName LIKE '刘%'
  --查询姓刘的同学，名字后面只有一个字的
  SELECT `studentNo` , 'studentName` FROMstudent'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`studentWHERE `Address` IN('安徽','河南洛阳');
    --====null not nu1l====
  --查询地址为空的学生 null''
  SELECT `studentNo' , 'studentName`FROMstudent'WHERE address=''OR address IS NULL
  --查询有出生日期的同学不为空
  SELECT studentNo', 'studentName FROM 'studentWHERE `BornDate IS NOT NULL
  --查询没有有出生日期的同学为空
  SELECTstudentNo`, studentName`FROM^studentWHERE`BornDate IS NULL
  
  
  
  
  
  --=========模糊查询==============
  SELECT `id`,`name` FROM student
  WHERE `address` IS NULL
  
  SELECT `id`,`name` FROM student
  WHERE `address` IS NOT NULL
  
  SELECT `id`,`name` FROM student
  WHERE `name` LIKE ('王%')
  
  SELECT `id`,`name` FROM student
  WHERE `name` LIKE ('%海%')
  
  SELECT `id`,`name` FROM student
  WHERE `name` LIKE ('周_')
  
  SELECT `id`,`name` FROM student
  WHERE `id` IN(7,8,9)
  
  
  SELECT `id`,`name` FROM student
  WHERE `id` BETWEEN 7 AND 9
  
  
  

4.4联表查询join on详解

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VB9mFjd0-1612504405408)(C:\Users\whl151885\AppData\Roaming\Typora\typora-user-images\image-20210128104748325.png)]

=========联表查询join ===三=======
--查询参加了考试的同学（学号，姓名，科目编号，分数）SELECT *FROM student
SELECT *FROM result
/*思路
1．分析需求，分析查询的字段来自哪些表，(连接查询)2．确定使用哪种连接查询?7种
确定交叉点(这两个表中哪个数据是相同的>
判断的条件:学生表的中 studentNo =成绩表studentNo*/
SELECT s.studentNO,studentName, SubjectNo, StudentResultFROM student As s
INNER JOIN result AS r
ON s.studentNO = r.studentNO
-- Right Join
SELECT s.studentNO,studentName , SubjectNo, StudentResultFROM student s
RIGHT JOIN result r
ONs.studentNO = r.studentNO
-- Left Join
SELECT s.studentNO,studentName , SubjectNo ,StudentResultFROM student s
LEFT JOIN result r
ON s.studentNO = r.studentNO

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

-- 思考题（查询了参加考试的同学信息:学号，学生姓名，科目名，分数)
/*思路
1．分析需求，分析查询的字段来自哪些表， student、result、subject（连接查询)2．确定使用哪种连接查询?7种
确定交叉点(这两个表中哪个数据是相同的>
判断的条件:学生表的中 studentNo =成绩表studentNo*/

SELECT s.studentNo, studentName , SubjectName, 'studentResult 'FROM student s
RIGHT JOIN result r
ON r.studentNo = s.studentNoINNER JOIN`subject` sub
ON r.SubjectNo = sub. subjectNo

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




INSERT INTO `grade` (`gradeid`,`grameName`,`name`)
VALUES(9,'二','周洁')


CREATE TABLE `grade`(
`gradeid` INT(9) NOT NULL,
`grameName` VARCHAR(8) NOT NULL,
`name` VARCHAR(8),
PRIMARY KEY(`gradeid`)
)ENGINE=INNODB DEFAULT CHARSET=utf8


--========联表查询 JOIN ON======
SELECT id,sex,s.name,grameName
FROM student AS s
INNER JOIN grade AS g
ON s.name=g.name
 
 
SELECT DISTINCT s.name,id,grameName
FROM student AS s
LEFT JOIN grade AS g
ON s.name=g.name

SELECT DISTINCT g.name,id,grameName
FROM student AS s
RIGHT JOIN grade AS g
ON s.name=g.name

自连接

--查询父子信息:把一张表看为两个一模一样的表
SELECT a.'categoryName` AS '父栏目',b.`categoryName AS '子栏目'FROM'category As a, 'category As b
WHERE a. 'categoryid` = b.'pid





--============自联表==========

SELECT a.`grameName` AS '父栏位',b.`grameName` AS '子栏位'
FROM grade AS a
JOIN grade AS b
ON a.gradeid=b.gradeid

4.5分页与排序

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HLzzWWwr-1612504405411)(C:\Users\whl151885\AppData\Roaming\Typora\typora-user-images\image-20210128154323021.png)]

--排序:升序ASC ，降序DESC
ORDER BY通过那个字段排序，怎么排
--查询的结果根据成绩降序排序
SELECT s. 'studentNo `, 'studentName `, 'subjectName `, 'studentResult5FROM student s
INNER30IN `result` r
ON s.studentNo = r.studentNo 
INNER JoIN `subject` sub
oN r.`subjectNo = sub. `subjectNo1WHERE` subjectName = '数据库结构-1'
ORDER BY StudentResult Asd

-- 100万
--为什么要分页?
--缓解数据库压力，给人的体验更好，瀑布流
--分页，每或只显示五条数据
--语法:limit起始值，页面的大小
--网页应用:当前，总的页数，页面的大小-- LIMIT 0,51~5
--LIMIT 1,52~6-- Limit 6,5
SELECT s.'studentNo `, 'studentName ', 'subjectName ', 'studentResultFROM student s
INNERJOINresult` r
ON s.studentNo = r.studentNo工NNERJoIN `subject` sub
ON r. `subjectNo° = sub. 'subjectNoWHERE subjectName = '数据库结构-1'ORDER BY StudentResu1t ASC

--================分页   LIMIT  和排序  ORDER BY ===========

SELECT `id`,`name`
FROM student
ORDER BY `id` DESC


SELECT `id`,`name`
FROM student
LIMIT 0,5



LIMIT 5,5
--第一页7imit o,5
(1-1）* 5
--第二页7imit 5 ,5
(2-1) *5
第三页 7imit 10,5
(3-1)*5
第N页7imit o, 5
(n-1) * pagesize，pagesize
【pagesize:页面大小】
【(n-1)* pagesize:起始值】【n :当前页】
-【数据总数/页面大小=总页数】

LIMIT 5,5
–第一页7imit o,5
(1-1） 5*
–第二页7imit 5 ,5
*(2-1) 5
第三页 7imit 10,5
(3-1)5
第N页7imit o, 5
(n-1) * pagesize，pagesize
【pagesize:页面大小】
【(n-1) pagesize:起始值】【n :当前页】
-【数据总数/页面大小=总页数】

4.6子查询和`嵌套查询

--1、查询数据库结构-1的所有考试结果（学号，科目编号，成绩），降序排列--方式一:使用连接查询
SELECT `studentNo`,r. 'subjectNo`, `studentResultFROM `result`r
工NNER JOIN`subject ` sub
ONr.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'
--查询所有数据库结构-1 的学生学号

--分数不小于80分的学生的学号和姓名
SELECT DISTINCT s.'studentNo`, studentNameFROM student s
工NNER OIN result r
ON r.studentNo = s.studentNoWHERE `studentResult`>=80
--在这个基础上增加一个科目，高等数学-2--查询高等数学-2的编号
SELECT DISTINCT s.'studentNo`, 'studentNameFROM student s
INNER JOIN result r
ON r.studentNo = s.studentNo
WHERE ‘studentResult '>=80 AND subjectNo= (SELECT subjectNo FROM^subjectT
WHERE `subjectName’= '高等数学-2'
--在改造(由里及外)
SELECT studentNo , studentName FROM student WHERE StudentNo IN (
SELECT studentNo FROM resu7t WHERE StudentResu7t>80 AND subjectNo = (SELECT subjectNo FROM 'subject` wHERE `subjectName`= '高等数学-2'
                                                                     
--在改造(由里及外)
SELECT studentNo ,studentName FROM student WHERE StudentNo IN （
SELECT studentNo FRoM result wHERE StudentResult>80 AND subjectNo = (SELECT subjectNo FROM `subjectwHERE ‘subjectName= '高等数学-2')

                            
                                                                     
                                                                     
 --=============子查询===================
--查询grameName为大二的 且性别为女的学生
SELECT s.`name`,`sex`,`grameName`
FROM student AS s
INNER JOIN grade AS g
WHERE s.`name`=g.`name` AND sex='女'

--=====子查询===
SELECT `name`,`sex`
FROM student
WHERE sex='女' AND `name` IN (
SELECT `name` 
FROM grade
WHERE `grameName`='大二'
)

4.7、分组和过滤

--查询不同课程的平均分，最高分，最低分，平均分大于80
--核心:(根据不同的课程分组)
SELECT SubjectName，AVG(StudentResu1t) AS 平均分,AX(StudentResu7t)AS最高分,MIN(studentResult)AS最低分
FROM result r
INNERJOIN subject` sub
ON r. subjectNo = sub. subjectNo
GROUP BY r.subjectNo --通过什么字段来分组
HAVING平均分>80

4.8select小结

顺序很重要:
select去重要查询的字段

from表(注意:表和字段可以取别名) as xoxx

join要连接的表

on等值判断
where(具体的值,子查询语句)

Group By(通过哪个字段来分组)
Having (过滤分组后的信息，条件和where是一样的，位置不同)

Order By …(通过哪个字段排序)[升序/降序]
Limit startlndex,pagesize
业务层面:
查询:跨表,跨数据库…

5.mysql函数

5.1常用函数

--================================常用函数======================
--数学运算
SELECT ABS(-8)--绝对值
SELECT CEILING(9.4)--向上取整SELECTFLOOR (9.4)-―向下取整
SELECT RAND ()--返回一个0~l之间的随机数
SELECT SIGN (10)--判断一个数的符号0-0负数返回-1，正数返回1
-―字符串函数
SELECT CHAR_ LENGTH('即使再小的帆也能远航')--字符串长度SELECT CONCAT ('我'，'爱','你们') --拼接字符串
SELECT INSERT('我爱编程helloworld'，1,2,'超级热爱')--查询，从某个位置开始替换某个长度SELECTLOWER( ' Kuangshen' ) --小写字母
SELECT UPPER（ 'zhoujie' ) --大写字母
SELECT INSTR ( 'zhoujie' , 'i') -- 返回第一次出现的子串的索引
SELECT REPLACE('周洁坚持就能成功','坚持', 努力')--替换出现的指定字符串
SELECT SUBSTR ('周洁坚持就能成功' ,4,6) --返回指定的子字符串 (源字符串,截取的位置，截取的长度)SELECTREVERSE('清晨我上马')--反转

 --查询姓周的同学．改成姓王
SELECT REPLACE(studentname,'周'，'王')FROM studentWHEREi studentname LIKE '周%'
-一时间和日期函数（记住)
SELECT CURRENT_DATE --获取当前日期SELECT CURDATE --获取当前日期
SELECT NOw( --获取当前的时间SELECT LOCALTIME --本地时间SELECT SYSDATE(1-系统时间
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(|
              

5.2聚合函数

函数名称	描述
COUNT()	计数
SUM()	求和
AVG()	平均值
MAX()	最大值
MIN()	最小值

-- ======聚合函数====
--都能够统计表中的数据(想查询一个表中有多少个记录，就使用这个count() )
SELECT COUNT(`BornDate ') FROM student; -- Count(字段)，会忽略所有的nu11值SELECT COUNT(*)FRoM student; -- Count (*)，不会忽略 nu11值，本质计算行数
SELECT COUNT(1) FROM result;-- Count (1)，不会忽略忽略所有的nul1值本质计算行数
SELECT SUM( `studentResult') AS总和FROM result
SELECT AVG('studentResult`) AS 平均分FROM resultSELECT MAX(studentResult') AS最高分FROM resultSELECT MIN( `studentResult` AS 最低分 FROM result

5.3、数据库级别的MD5加密（扩展)

什么是MD5?
主要增强算法复杂度和不可逆性。
MD5不可逆，具体的值的md5是一样的
MD5破解网站的原理，背后有一个字典,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, ' zhangsan' , '123456'),(2,'7isi' , '123456'),(3 , ' wangwu ',
--加密
UPDATE testmd5 SET pwd=MD5(pwd) wHERE id = 1
UPDATE testmd5 SET pwd=MD 5(pwd) --加密全部的密码
--插入的时候加密
INSERT INTO testmd5 VALUES(4, 'xiaoming' ,MD5('123456'))
--如何校验:将用户传递进来的密码，进行md5加密，然后比对加密后的值
SELECT*FROM testmd5 wHERE ‘name'='xiaoming' AND pwd=MD5( '123456 ')
        
        
        
        
        
        
        
        
        
--=============MD5加密============
CREATE TABLE `textMd5`(
`id` INT(8) NOT NULL,
`name` VARCHAR(20) NOT NULL,
`pwd` VARCHAR(50) NOT NULL,
PRIMARY KEY(`id`)
)
ENGINE=INNODB DEFAULT CHARSET=utf8


--======插入数据
INSERT INTO `textmd5` VALUES (1,'hfshhh','123432'),(2,'hhdshh','123432'),(3,'hhhh','123432')


UPDATE `textmd5` SET `pwd`=MD5(pwd)
        

6、事务

6.1、什么是事务

要么都成功，要么都失败

---

1、SQL执行A给B转账

A1000—>200 B 200

2、SQL执行B收到A的钱

A800—>B 400

---

将一组SQL放在一个批次中去执行~
事务原则: ACID原则原子性 ,一致性，隔离性，持久性 (脏读，幻读…)

原子性(Atomicity)

要么都成功，要么都失败

一致性(Consistency)
事务前后的数据完整性要保证一致，1000
持久性(Durability)—事务提交
事务一旦提交则不可逆，被持久化到数据库中!

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

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

6.2测试事务实现转账

-- ==============事务==================
-- mysq1是默认开启事务自动提交的
SET autocommit = o/*关闭*/
SET autocommit = 1/*开启（默认的）*/
--手动处理事务
SET autocommit = 0 --关闭自动提交
--事务开启
START TRANSACTION -- 标记一个事务的开始，从这个之后的 sq1 都在同一个事务内
INSERT XX
INSERT XX
--提交:持久化(成功!)COMMIT
--回滚:回到的原来的样子（失败! )ROLLBACKI
--事务结束
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(8) 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'  -- A减500
UPDATE `account` SET money= money+500 WHERE `name`='B'  -- B加500

COMMIT;  -- 提交事务,自动提交
ROLLBACK; -- 回滚

SET autocommit = 1; -- 重新打开自动提交(恢复默认值)

7、索引

MySQL官方对索引的定义为:索引(Index）是帮助MySQL高效获取数据的数据结构。0.55
0.00001s
提取句子主干，就可以得到索引的本质:索引是数据结构。

7.1、索引的分类

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

基础语法
-- 索引的使用
-- 1、在创建表的时候给字段增加索引
-- 2、创建完毕后，增加索引
--显示所有的索引信息
SHOw INDEX FROM student
--增加一个全文索引（索引名）列名
ALTER TABLE schoo1.student ADD FULLTEXT INDEX studentName ( studentName );
-- EXPLAIN分析sq1执行的状况
EXPLAIN SELECT *FROM student; --非全文索引
EXPLAIN SELECT*FROM student WHERE MATCH(studentName) AGAINST('刘');



ALTER TABLE 数据库名.表名 ADD 索引类型名 index 索引名(列名)

7.2测试索引

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

-- 插入100万数据.
DELIMITER $$
-- 写函数之前必须要写，标志
SET GLOBAL log_bin_trust_function_creators=TRUE;
CREATE FUNCTION mock_data ()
RETURNS INT DETERMINISTIC
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),'19224305@qq.com','123456789',FLOOR(RAND()*2));
		SET i=i+1;
	END WHILE;
	RETURN i;
END;

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

作用:索引在大数据时可以减少访问的时间(在百万级的大数据以上中效果更明显)

7.3、索引原则

·索引不是越多越好
·不要对进程变动数据加索引·小数据量的表不需要加索引
·索引一般加在常用来查询的字段上!
索引的数据结构
Hash类型的索引
Btree : InnoDB的默认数据结构~
阅读:http://blog.codinglabs.org/articles/theory-of-mysql-index.html

8.权限管理和备份

8.1用户管理

1.mysql yog管理

直接在MySQL yog中的用户管理中进行管理

2.sql语句管理

-- 创建用户CREATE USER用户名IDENTIFIED BY '密码'
CREATE USER wanghailin IDENTIFIED BY '123456'
-- 修改密码（修改当前用户密码)
SET PASSWORD = PASSWORD( '123456 ')
-- 修改密码(修改指定用户密码)
SET PASSWORD FOR wanghailin = PASSWORD( '123456')
-- 重命名RENAME USER原来名字 TO 新的名字
RENAME USER wanghailin To zhoujie
-- 用户授权ALL PRIVILEGES全部的权限，库.表
-- ALL PRIVILEGES 除了给别人授权，其他都能够干
GRANT ALL PRIVILEGES ON *. * To zhoujie
-- 查询权限
SHOw GRANTS FOR wanghailin
--查看指定用户的权限
SHOW GRANTS FORroot@localhost
-- ROOT用户权限:GRANT ALL PRIVILEGES ON *.*To 'root' @'loca7host' wITH GRANT OPTION
-―撤销权限 REVOKE哪些权限，在哪个库撤销,给谁撤销
REVOKE ALL PRIVILEGES ON*.*FROM zhoujie
--删除用户
DROP USER wanghailin

8.2备份

1.使用MySQL yog 在所想备份的数据库右键后 选择备份即可

导入时直接将文件拖到应用框中即可

2.使用mysql语句备份与导入

·使用命令行导出mysqldump命令行使用
# mysq1dump -h 主机 -u用户名 -p 密码数据库表名>物理磁盘位置/文件名
mysq1dump -hloca1host -uroot -p123456 school student >D:/a.sq1
# mysqldump -h 主机 -u用户名 -p 密码―数据库﹑表1表2表3>物理磁盘位置/文件名
 mysq7dump -hloca1host -uroot -p123456 schoo7 student >D:/b.sq1
 # mysq7dump -h 主机 -u用户名 -p 密码―数据库>物理磁盘位置/文件名
 mysqldump -h1ocalhost -uroot -p123456 schoo1 >D:/c.sq1
#导入
#登录的情况下，切换到指定的数据库
# source备份文件
source d : /a.sq1
mysq1 -u用户名-p密码库名<

9.规范数据库设计

9.1、为什么需要设计

当数据库比较复杂的时候，我们就需要设计了糟糕的数据库设计:
·数据冗余，浪费空间
·数据库插入和删除都会麻烦、异常【屏蔽使用物理外键】·程序的性能差
良好的数据库设计:·节省内存空间
·保证数据库的完整性·方便我们开发系统
软件开发中，关于数据库的设计
·分析需求:分析业务和需要处理的数据库的需求
I
·概要设计:设计关系图E-R图

设计数据库的步骤:(个人博客)·收集信息，分析需求
。用户表（用户登录注销，用户的个人信息，写博客，创建分类)。分类表(文章分类，谁创建的)
。文章表(文章的信息)
。评论表
。友链表(友链信息)
。自定义表(系统信息，某个关键的字，或者一些主字段)key : value。说说表（发表心情… id… content…create_time)
·标识实体(把需求落地到每个字段)
·标识实体之间的关系
。写博客:user - blog
。创建分类:user -> category。关注:user ->user
。友链:links
。评论: user-user-blog

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Teh09PNV-1612504405413)(file:///C:\Users\whl151885\Documents\Tencent Files\2076312724\Image\C2C\15$A81BZBDR4~WM}USZ4{QT.png)]

9.2三大范式

三大范式

第一范式（1NF)

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

第二范式(2NF)

前提:满足第一范式每张表只描述一件事情

第三范式(3NF)
前提:满足第一范式和第二范式
第三范式需要确保数据表中的每一列数据都和主键直接相关，而不能间接相关。

(规范数据库的设计)
规范性和性能的问题
关联查询的表不得超过三张表
·考虑商业化的需求和目标，（成本，用户体验! ）数据库的性能更加重要·在规范性能的问题的时候，需要适当的考虑一下规范性!
·故意给某些表增加一些冗余的字段。(从多表查询中变为单表查询)·故意增加一些计算列(从大数据量降低为小数据量的查询:索引)

10.JDBC(重点)

10.1数据库驱动

10.2JDBC

java.sqljavax.sql
还需要导入一个数据库驱动包mysql-connector-java-5.1.47.jar

10.3第一个JDBC程序

package com.wang.lesson01;

import java.sql.*;


public class JdbcFirstDemo {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
       //通过idea连接数据库
        //1.加载驱动
       Class.forName("com.mysql.cj.jdbc.Driver");
       //2.用户信息 url
        String url = "jdbc:mysql://localhost:3306/jdbcStudy?useUnicode=true&characterEncoding=utf8&useSSL=true";
        String username = "root";
        String password = "123456";
        //3.连接数据库对象
        Connection connection = DriverManager.getConnection(url, username, password);
        //4.去执行connection数据库对象的 statement 执行sql的对象
        Statement statement = connection.createStatement();
        //5.执行sql的对象 得到返回  结果集 resultSet
        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"));
            System.out.println("=================");
        }
        //6.关闭连接
        resultSet.close();
        statement.close();
        connection.close();
    }
}

步骤总结:

1、加载驱动
2、连接数据库 DriverManager

3、获得执行sql的对象Statement

4、获得返回的结果集
5、释放连接

DriverManager

DriverManager.registerDriver(new com.mysq1.jdbc.Driver();2class.forName("com.mysq1.jdbc.Driver");//固定写法，加载驱动
 connection connection = DriverManager.getconnection(ur1，username，password);
 connection代表数据库
//数据库设置自动提交
//事务提交
//事务滚回
connection .ro11back();
connection. commit();
connection . setAutocommit();|

URL

1string ur1 = "jdbc :mysq7: / /localhost:3306 jdbcstudy?
useunicode=true&characterEncoding=utf8&usessL=true";
//mysql -- 3306
//协议://主机地址:端口号/数据库名?参数1&参数2&参数35
//oralce -- 1521
//jdbc:oracle:thin : alocaThost:1521:sid

Statement 执行SQL的对象PrepareStatement 执行SQL的对象

string sq1 = "SELECT *FROM users";//编写sQL
statement.executeQuery(;//查询操作返回 
Resultsetstatement.execute(; //执行任何sQL
statement.executeupdate();//更新、插入、删除。都是用这个，返回一个受影响的行数

Resultset查询的结果集:封装了所有的查询结果

获得指定的数据类型
resu7tset.getobject(;//在不知道列类型的情况下使用
//如果知道列的类型就使用指定的类型
resu1tset.getstring();
resultset.getInt();
resu1tset. getFloat();
resultset. getDate();
resultset.getobject();
 ....

遍历，指针

//resultset.beforeFirst(;//移动到最前面
resultset.afterLast();//移动到最后面

resultset.next();//移动到下一个数据
resultset.previous();//移动到前一行

resultset.absolute(row);//移动到指定行

10.4、statement对象

Jdbc中的statement对象用于向数据库发送SQL语句」想完成对数据库的增删改查，只需要通过这个对象向数据库发送增删改查语句即可。
Statement对象的executeUpdate方法，用于向数据库发送增、删、改的sql语句，executeUpdate执行完后，将会返回一个整数（即增删改语句导致了数据库几行数据发生了变化)。
Statement.executeQuery方法用于向数据库发送查询语句，executeQuery方法返回代表查询结果的ResultSet对象。

CRUD操作-create

//使用executeUpdate(String sql)方法完成数据添加操作，示例操作:
statement st = conn. createstatement();
string sql = "insert into user(.... ) 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 user where id=1";
int num = st.executeupdate(sq1);
if(num>0){
system.out.print1n(“删除成功! ! ! ");
                   }

CRUD操作-update

使用executeUpdate(String sql)方法完成数据修改操作，示例操作:
statement st = conn. createstatement();
string sq1 = "update user set name='' where name=''";
int num = st.executeupdate(sq1);
if(num>0){
    system. out.print1n(“修改成功!! ! ");
}

1.插入

package com.wang.lesson02;

import com.wang.lesson02.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 conn = null;
        Statement st = null;
        ResultSet rs = null;

        try {
            conn = JdbcUtils.getConnection();
            st = conn.createStatement();//获得sql的执行对象
            String sql = "INSERT INTO `users`(id,NAME,PASSWORD,email,birthday)VALUES (4,'wanghailin','123456','2076312724@qq.com','2000-12-04')";

            int i = st.executeUpdate(sql);
            if(i>0){
                System.out.println("插入成功!");
            }

        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            JdbcUtils.release(conn,st,rs);
        }
    }
}

2.删除

package com.wang.lesson02;

import com.wang.lesson02.Utils.JdbcUtils;

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

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

        try {
            conn = JdbcUtils.getConnection();
            st = conn.createStatement();//获得sql的执行对象
            String sql = "DELETE FROM `users` WHERE `id`=4";
            int i = st.executeUpdate(sql);
            if(i>0){
                System.out.println("删除成功!");
            }

        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            JdbcUtils.release(conn,st,rs);
        }
    }
}

3.更新

package com.wang.lesson02;

import com.wang.lesson02.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 conn = null;
        Statement st = null;
        ResultSet rs = null;

        try {
            conn = JdbcUtils.getConnection();
            st = conn.createStatement();//获得sql的执行对象
            String sql = "UPDATE `users` SET `NAME`='zhoujie' WHERE `id` = 1";
            int i = st.executeUpdate(sql);
            if(i>0){
                System.out.println("更新成功!");
            }

        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            JdbcUtils.release(conn,st,rs);
        }
    }
}

4.查询

package com.wang.lesson02;

import com.wang.lesson02.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 conn = null;
        Statement st = null;
        ResultSet re = null;

        try {

            conn = JdbcUtils.getConnection();//1.连接数据库
            st = conn.createStatement();//2.设置执行sql
            String sql = "select * from users where id = 1";
            re = st.executeQuery(sql);
            while(re.next()){
                System.out.println("id="+re.getObject("id"));
                System.out.println("NAME="+re.getObject("NAME"));
                System.out.println("PASSWORD="+re.getObject("PASSWORD"));
                System.out.println("email="+re.getObject("email"));
                System.out.println("birthday="+re.getObject("birthday"));
                System.out.println("============");
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally{
            JdbcUtils.release(conn,st,re);
        }


    }
}

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

package com.wang.lesson02;

import com.wang.lesson02.Utils.JdbcUtils;

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

public class SQL注入 {
    public static void main(String[] args) {
        System.out.println("请输入账号与密码:");
        Scanner in = new Scanner(System.in);//开启输入
        String nameuser = in.next();
        String password = in.next();
        login("nameuser","password");

    }
    //账号登录 通过数据库查询
        public static void login(String nameuser,String password){
            Connection conn = null;
            Statement st = null;
            ResultSet re = null;

            try {

                conn = JdbcUtils.getConnection();//1.连接数据库
                st = conn.createStatement();//2.设置执行sql
                String sql = "SELECT * FROM `users` WHERE `NAME`='"+nameuser+"' AND `PASSWORD`='"+password+"'";
                re = st.executeQuery(sql);
                while(re.next()){
                    System.out.println("id="+re.getObject("id"));
                    System.out.println("NAME="+re.getObject("NAME"));
                    System.out.println("PASSWORD="+re.getObject("PASSWORD"));
                    System.out.println("email="+re.getObject("email"));
                    System.out.println("birthday="+re.getObject("birthday"));
                    System.out.println("============");
                }
                if(!re.next()){
                    System.out.println("查无此人!");
                }
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }finally{
                JdbcUtils.release(conn,st,re);
            }
        }

}

10.5、PreparedStatement对象

PreparedStatement可以防止SQL注入。效率更好!

1.插入

package com.wang.lesson03;

import com.wang.lesson02.Utils.JdbcUtils;

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

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

        try {
            conn = JdbcUtils.getConnection();//连接数据库
            //sql语句预处理
            String sql = "INSERT INTO `users`(id,NAME,PASSWORD,email,birthday)VALUES(?,?,?,?,?)";

            st = conn.prepareStatement(sql);//数据库所要执行的对象

            st.setInt(1,4);
            st.setString(2,"wanghailin");
            st.setString(3,"123456");
            st.setString(4,"2076312724@qq.com");
            st.setDate(5,new java.sql.Date(new Date().getTime()));

            int i= st.executeUpdate();
            if(i>0){
                System.out.println("插入成功!");
            }

        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally{
            JdbcUtils.release(conn,st,null);
        }
    }
}

2.删除

package com.wang.lesson03;

import com.wang.lesson02.Utils.JdbcUtils;

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

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

        try {
            conn = JdbcUtils.getConnection();
            String sql = "delete from users where id = ?";
            st=conn.prepareStatement(sql);

            st.setInt(1,4);

            int i = st.executeUpdate();
            if(i>0){
                System.out.println("删除成功!");
            }

        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally{
            JdbcUtils.release(conn,st,null);
        }
    }
}

3.更新

package com.wang.lesson03;

import com.wang.lesson02.Utils.JdbcUtils;

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

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

        try {
             conn = JdbcUtils.getConnection();
             String sql = "UPDATE `users` SET `NAME`=? WHERE `id` = ?";
             st = conn.prepareStatement(sql);

             st.setString(1,"周洁");
             st.setInt(2,1);

             int i = st.executeUpdate();
             if (i>0){
                 System.out.println("更新成功!");
             }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally{
            JdbcUtils.release(conn,st,null);
        }
    }
}

4.查询

package com.wang.lesson03;

import com.wang.lesson02.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 conn = null;
        PreparedStatement st = null;
        ResultSet re = null;

        try {
           conn = JdbcUtils.getConnection();

           String sql = "select * from users where id=?";
           st = conn.prepareStatement(sql);

           st.setInt(1,1);
           re = st.executeQuery();

           while(re.next()){
               System.out.println(re.getObject("NAME"));
           }

        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally{
            JdbcUtils.release(conn,st,re);
        }


    }
}

SQL注入问题解决

package com.wang.lesson03;

import com.wang.lesson02.Utils.JdbcUtils;

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

public class SQL注入 {

        public static void main(String[] args) {
            System.out.println("请输入账号与密码:");
            Scanner in = new Scanner(System.in);//开启输入
            String nameuser = in.nextLine();
            String password = in.nextLine();
            login(nameuser,password);

        }
        //账号登录 通过数据库查询
        public static void login(String nameuser,String password){
            Connection conn = null;
            PreparedStatement st = null;
            ResultSet re = null;

            try {

                conn = JdbcUtils.getConnection();//1.连接数据库

                String sql = "SELECT * FROM `users` WHERE `NAME`=? AND `PASSWORD`=?";

                st = conn.prepareStatement(sql);//2.设置执行sql


                st.setString(1,nameuser);
                st.setString(2,password);
                re = st.executeQuery();


                while(re.next()){
                    System.out.println("id="+re.getObject("id"));
                    System.out.println("NAME="+re.getObject("NAME"));
                    System.out.println("PASSWORD="+re.getObject("PASSWORD"));
                    System.out.println("email="+re.getObject("email"));
                    System.out.println("birthday="+re.getObject("birthday"));
                    System.out.println("============");
                }

            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }finally{
                JdbcUtils.release(conn,st,re);
            }
        }

    }

10.6使用idea连接数据库

rowables.printStackTrace();
}finally{
JdbcUtils.release(conn,st,re);
}

}

}

SQL注入问题解决

```java
package com.wang.lesson03;

import com.wang.lesson02.Utils.JdbcUtils;

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

public class SQL注入 {

        public static void main(String[] args) {
            System.out.println("请输入账号与密码:");
            Scanner in = new Scanner(System.in);//开启输入
            String nameuser = in.nextLine();
            String password = in.nextLine();
            login(nameuser,password);

        }
        //账号登录 通过数据库查询
        public static void login(String nameuser,String password){
            Connection conn = null;
            PreparedStatement st = null;
            ResultSet re = null;

            try {

                conn = JdbcUtils.getConnection();//1.连接数据库

                String sql = "SELECT * FROM `users` WHERE `NAME`=? AND `PASSWORD`=?";

                st = conn.prepareStatement(sql);//2.设置执行sql


                st.setString(1,nameuser);
                st.setString(2,password);
                re = st.executeQuery();


                while(re.next()){
                    System.out.println("id="+re.getObject("id"));
                    System.out.println("NAME="+re.getObject("NAME"));
                    System.out.println("PASSWORD="+re.getObject("PASSWORD"));
                    System.out.println("email="+re.getObject("email"));
                    System.out.println("birthday="+re.getObject("birthday"));
                    System.out.println("============");
                }

            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }finally{
                JdbcUtils.release(conn,st,re);
            }
        }

    }

10.6使用idea连接数据库