最简SQL学习笔记

MySQL

mysql -u root -p123456--通过Dos命令打开数据库
flush privileges--刷新权限
--所有语句使用;结束。
mysql >use school
Datadase changed--切换数据库成功
show tables;--打开所有表
describe student;--打开student表并查看信息
exit;--退出mysql
--使用表名或字段名需要用``引起来

操作数据库

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

mysql关键字不区分大小写

操作数据库

1.创建数据库

CREATE DATABASE IF NO EXISTS westos 

2.删除数据库

DROP DATABASE westos

3.使用数据库

使用表名或者字段名需要带``

USE `school`

4.查看数据库

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

数据库的列类型

数值：

tinyint 十分小的数据 1字节

smallint 较小的数据 2字节

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

int 标准的整数 4个字节（常用）

bigint 较大的整数 8个字节

float 单精度浮点数 4个字节

double 双精度浮点数 8个字节

decimal 字符串形式的浮点数 金融计算的时候， 一般使用decimal

字符串：

char 字符串固定大小0~255

varchar 可变字符串 0~65535 常用的变量 String

tinytext 微型文本 2^8-1

text 文本串 2^16-1 保存大文本（文章）

时间日期：

data YYYY-MM-DD，日期格式

time HH：mm:ss，时间格式

datatime YYYY-MMM-DD HH:mm:ss 最常用的时间格式

timetamp 时间戳， 1970.1.1到现在的毫秒数! 也比较常用

year年份表示

null

没有值，未知

注：不用null进行运算，结果为null

数据库字段属性

Unsigned:

无符号整数，该列不能声明为负数

Zerofill:

0填充，不足的位数用0填充

自增：

通常理解自增在上一条记录的基础上加一，一般使用该字段为主键，必须为整数类型

可以自定义设计主键的起始值和步长

非空：NULL NOT NULL

假设设置为not null如果不赋值则会报错

null不赋值的情况下不会报错

默认：

设置默认字段

每一张表必有的五个字段，做项目使用

ID主键

version 乐观锁

is_delete 伪删除

gmt_create 创建时间

gmt_update 修改时间

数据库的创建

/*--注意，使用英文（），表的名称和字段尽量使用``括起来
--autoincrement自增
--所有语句后面加英文状态下的逗号最后一个不用加
--primary key主键，一般一个表只有一个唯一的主键！*/
CREATE TABLE IF NOT EXISTS`student1`(
  `id` int(4) not null auto_increment comment'学号',
  `name` VARCHAR(30) NOT NULL DEFAULT'匿名' COMMENT'姓名',
   primary key(`id`)
)ENGINE=INNODB DEFAULT CHARSET=utf8

常用命令：

SHOW CREATE DATABASE school--查看创建数据库的语句
SHOW CREATE TABLE student/*查看student数据表定义语句*/
DESC student1/*显示表的结构*/

关于数据库引擎

INNODB默认使用

MYISAM早些年使用支持索引

数据库的字符集编码

CHARSET=utf8

不设置默认为不支持中文的编码。

修改表：

/*修改表名*/
ALTER TABLE student1 RENAME AS teacher
-- 增加表的字段
ALTER TABLE teacher ADD age INT(5)
-- 修改表的字段
ALTER TABLE teacher MODIFY age VARCHAR(11)-- 修改字段名约束
ALTER TABLE teacher CHANGE age age1 INT(10)-- 字段重命名
-- 删除字段
ALTER TABLE teacher DROP age1

删除表：

DROP TABLE IF NO EXISTS teacher

在创建和删除时最好加上判断，字段名用``括起来

数据管理

外键：删除有外键关系的表，先删除主表，再删除从表。

ALTER TABLE `student`-- 添加外键
ADD CONSTRAINT `Fk_gradeid` FOREIGN KEY (`gradeid`)REFERENCES `grade`(`gradeid`);

不建议使用，外键添加在程序中书写。

DML语言

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

DML 语言：数据操作语言

insert：添加

-- 插入语句
-- insert into 表名（`字段名1`,`字段名2`）values(`值1`),(`值2`)
INSERT INTO `grade`(`gradename`)  VALUES('大四')
INSERT INTO `student`(`id`,`name`)VALUES('6','jack')

update：修改

UPDATE `student`SET `name`='jerry' WHERE id=4; 

含义	操作符	范围	结果
等于	=	5=6	FALSE
不等于	<>或！=
大于	>
小于	<
大于等于	>=
小于等于	<=
在某个范围内	BETWEEN … AND	[2,5]
和	AND	5>1AND1>2	FALSE
或	OR	5>1OR1>2	TRUE

-- 通过多个条件定位数据
UPDATE `student`SET `name`='jack'WHERE`name`='tom'AND `sex`='女'

注意：

colnum-name是数据库的列尽量带上``

条件，筛选的条件如果没有指定，则会修改所有的列

value,是一个具体的值也可以是一个变量

多个设置属性之间，使用英文逗号隔开。

trim,可以解决多余的逗号

delete：删除

DELETE FROM `student`WHERE `id`=3;

TRUNCATE清空表数据，不破坏表数据。

delete和truncate相同点与不同点

相同点：删除表中数据

不同点：truncate 重置自增列计数器归零，且不会影响事物。delete不会影响自增列

查询数据

学校数据库

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;

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

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

-- 插入成绩数据 这里仅插入了一组，其余自行添加
INSERT INTO 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);

-- 创建学生表
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','[email protected]','123456198001011234'),
(1001,'123456','赵强',1,3,'13800002222','广东深圳','1990-1-1','[email protected]','123456199001011233');

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

-- 插入科目数据
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* FROM grade
SELECT* FROM `subject`
-- 查询指定字段
SELECT `subjectno`,`subjectname`FROM `subject`
SELECT `subjectno` AS 课程编号,`subjectname` AS 课程名称 FROM `subject`
-- 函数Concat(a,b)
SELECT CONCAT('class：',subjectname)AS `newname`FROM `subject`

去重distinct

SELECT`studentno`FROM result
SELECT DISTINCT `studentno`FROM `result`;

去除数据库中查询出来的相同的数据。

数据库的列：

SELECT VERSION()-- 查询系统版本
SELECT 100+3+9 AS 计算结果-- 用来计算
SELECT @@auto_increment_increment-- 查询自增的步长
SELECT `studentno`,`studentresult`FROM `result`
SELECT `studentno`,`studentresult`+1 AS '提分成绩' FROM `result`

where 条件子句：

检索符合条件的值

逻辑运算符：搜索条件由一个或多个表达式组成，结果为布尔值。

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

尽量使用中文避免出错。

SELECT `studentno`,`studentresult`FROM `result`
WHERE `studentresult`>=95 AND `studentresult`<=100
SELECT `studentno`,`studentresult`FROM `result`
WHERE `studentresult` BETWEEN 95 AND 100
-- 除了学号1001同学之外的成绩
SELECT `studentno`,`studentresult`FROM `result`
WHERE `studentno`!=1001;
SELECT `studentno`,`studentresult`FROM `result`
WHERE NOT `studentno`=1001;

模糊查询：比较运算符

运算符	语法	描述
IS NULL	a is null	如果操作符为NULL，结果为真
IS NOT NULL	a is not null	如果操作符不是NULL，结果为真
BETWEEN	a between b and c	若a在b和c之间，则结果为真
Like	a like b	sql匹配，如果a 匹配b，则结果为真
In	a in(a1,a2,a3…)	假设a在a1,a2…中间某一个值中，结果为真

SELECT `studentno`,`studentname`FROM `student`
WHERE `studentname`LIKE'赵%'
SELECT `studentno`,`studentname`FROM `student`
WHERE `studentname`LIKE'赵_'
-- %表示任意一个字符，_表示一个字符

in:

SELECT `studentno`,`studentname`FROM `student`
WHERE `studentno`IN(1000);

null is not null

SELECT `studentno`,`studentname`FROM `student`
WHERE `address`='';
SELECT `studentno`,`studentname`FROM `student`
WHERE `borndate` IS NOT NULL

联表查询

inner join

SELECT s.studentno,studentname,subjectno,studentresult FROM student AS s INNER JOIN result AS r ON s.studentno=r.studentno
SELECT s.studentno,studentname,subjectno,studentresult FROM student AS s INNER JOIN result AS r WHERE s.studentno=r.studentno
--  join(连接的表)on （判断条件）连接查询
  -- where 等值查询

SELECT s.studentno,studentname,`subjectname`,student result
FROM `student`AS s
RIGHT JOIN result AS r
ON r.studentno=s.studentno
INNER JOIN `subject` sub
ON r.subjectno=sub.subjectno

分页和排序（limit and order by）

排序：升序ASC和降序DESC

ORDER BY studentresult ASC-- 升序

分页：环节数据库压力

第1页 limit 0,5

第2页 limit 5,5

第3页 limit 10,5 （n-1）*pagesize,pagesize

pagesize :页面大小

（n-1）*pagesize:起始值

n:当前页

数据总数/页面大小=总页数

SELECT s.studentno,studentname,subjectno,studentresult FROM student AS s INNER JOIN result AS r WHERE s.studentno=r.studentno
 LIMIT 2,2

子查询：

-- 查询高等数学-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

分组和过滤

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 平均分>65

MySQL常用函数

5.1常用函数

SELECT ABS(-8)-- 绝对值
SELECT CEILING (9.4)-- 向上取整
SELECT FLOOR(8.8) -- 向下取整
SELECT RAND() -- 返回一个0~1之间的随机数
SELECT SIGN(10) -- 返回一个数的符号
-- 字符串函数
SELECT CHAR_LENGTH('hello') -- 字符串函数
SELECT CONCAT('你','好') -- 拼接字符串
SELECT INSERT('我爱编程哈哈哈哈',1,2,'bugu') -- 查询 替换 从某个位置开始替换某个长度
SELECT LOWER('I LOVE YOU') -- 小写字母
SELECT UPPER('i love you') -- 大写字母
SELECT  INSTR ('hello','l') -- 返回第一次出现子串的索引
SELECT REPLACE('天天爱学习','天天','乐乐') -- 替换指定的字符串
SELECT SUBSTR('asyugggggggfc bfsiuhfuigsyufgdyus',2,4) -- 返回指定的字符串（源字符串，截取位置，截取长度）
SELECT REVERSE('莫等闲，白了少年头！') -- 字符串反转
-- 时间和日期
SELECT CURRENT_DATE()-- 返回当前时间
SELECT NOW() -- 返回当前的时间
SELECT SYSDATE() -- 返回系统时间
SELECT YEAR(NOW())
-- 系统
SELECT SYSTEM_USER()-- 系统用户
SELECT VERSION() -- 系统版本

5.2聚合函数

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

-- =========聚合函数=========
 SELECT COUNT(studentname)FROM student-- 查找某字段数据的和
 SELECT COUNT(*)FROM student-- 本质计数，不会忽略所有的null 值
 SELECT COUNT(1)FROM student -- 同上
 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加密：

CREATE TABLE `testmd5` (
  `id` INT(4) NOT NULL,
  `name` VARCHAR(20) NOT NULL,
  `pwd` VARCHAR(50) NOT NULL,
  PRIMARY KEY (`id`)
 ) 
INSERT INTO testmd5 VALUES(1,'jack','123456'),
(2,'tom','123456'),(3,'jerry','123456')
UPDATE testmd5 SET pwd=MD5(pwd) -- 对全部密码进行加密
INSERT INTO testmd5 VALUES(4,'jackma',MD5('123456'))
SELECT *FROM testmd5 WHERE `name`='jackma'AND pwd=MD5('123456')

select小结：

select (distinct)去重 要查询的字段from表（注：字段和表可以取别名）

xxx join要连接的表 on 等值判断

where（具体的值，子查询语句）

Group By(通过哪个字段来分组)

Having(过滤分组后的信息，条件和where是一样的，位置不同)

Order By… （通过那个字段排序，升序还是降序）

limit startindex ,pagesize

事物

要么都成功，要么都失败。

ACID（原子性，一致性，持久性，隔离性）

原子性：要么都成功，要么都失败

一致性：事务前后数据完整性保持一致

持久性：事务一旦提交则不可逆，被持久化到数据库中

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

隔离导致的一些问题

脏读：某一事务读取了另一事务未提交的数据

不可重复读：在一个事务内读取表中的某一行数据，多次读取结果不同

虚读（幻读）：一个事务内读取了其他事务插入的数据，导致前后读取不一致。

事务开启流程

SET autocommit=0 -- 关闭事务自动提交
SET autocommit=1 -- 开启事务自动提交 mysql数据库默认是开启事务自动提交的
START TRANSACTION -- 标记一个事物的开始，从这个之后的sql 都在同一个事务内
INSERT xx
INSERT xx
-- 成功 提交 持久化
COMMIT
-- 失败回滚到开始
ROLLBACK
--  事务结束开启自动提交
SET autocommit=1

对事务操作流程：

CREATE DATABASE `shop`CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci; 
 SHOW DATABASES; 
 USE `shop`; 
 SHOW CHARSET; 
 SHOW COLLATION; 
 SHOW COLLATION; 
 CREATE TABLE `shop`.`account`( `id` INT(3) NOT NULL AUTO_INCREMENT, `name` VARCHAR(30)  NOT NULL, `money` DECIMAL(9,2) NOT NULL, PRIMARY KEY (`id`) ) ENGINE=INNODB      CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci; 
 SHOW TABLE STATUS FROM `shop` LIKE 'account'; 
 SHOW CHARSET; 
 SHOW FULL FIELDS FROM `shop`.`account`; 
 SHOW KEYS FROM `shop`.`account`; 
 SHOW COLLATION; 
 SHOW FULL TABLES FROM `shop` WHERE table_type = 'BASE TABLE'; 
 SHOW FULL TABLES FROM `shop` WHERE table_type = 'BASE TABLE'; 
 SHOW FULL TABLES FROM `shop` WHERE table_type = 'BASE TABLE'; 
 SELECT * FROM `shop`.`account` LIMIT 0, 1000; 
 SHOW CREATE TABLE `shop`.`account`; 
 SHOW FULL FIELDS FROM `shop`.`account`; 
 SHOW KEYS FROM `shop`.`account`; 
 INSERT INTO `shop`.`account` (`name`) VALUES ('A'); 
 INSERT INTO `shop`.`account` (`name`, `money`) VALUES ('A', '2000.00'); 
 INSERT INTO `shop`.`account` (`name`, `money`) VALUES('B', '10000.00'); 
SET autocommit=1
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;

索引的创建以及分类

索引的分类：

主键索引(primary key)：唯一的标识，主键不可重复，只能一个列作为主键

唯一索引(unique key)：避免重复的列出现，唯一索引可以重复

常规索引(key)：默认的可以通过index key 来设置

全文索引（fulltext）：在特定的数据库引擎下才有，MyISAM

快速定位数据

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

索引在数据量很大的时候，作用很明显。

索引原则

索引不是越多越好

不要对进程变动数据加索引

小数据量的表不需要

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

权限管理和备份

用户管理

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

sql命令

-- 创建用户CREATE USER 用户名 IDENTIFIED BY '密码'
CREATE USER tiantian IDENTIFIED BY '123456'
-- 修改密码（修改当前用户密码）
SET PASSWORD=PASSWORD('123456')
-- 修改密码（修改指定用户密码）
SET PASSWORD FOR tiantian =PASSWORD('123456')
-- 重命名 RENAME USER 原来的名字 TO新名字
RENAME USER tiantian TO tiantian2
-- 用户授权 ALL PRIVILEGES 全部权限，库，表TO 用户名  除了授权给其他用户其它权限如同ROOT
GRANT ALL PRIVILEGES ON *.* TO tiantian2
-- 查询权限
SHOW GRANTS FOR tiantian2
-- 撤销权限 revoke
REVOKE ALL PRIVILEGES ON *.*FROM tiantian2
-- 删除用户
DROP USER tiantian 

MySQL备份

1.直接拷贝data文件夹

2.在SQLyog中手动导出

3.使用命令行

mysqldump -hlocalhost -uroot -p123456 school student >d:/a.sql
# mysqldump -h 主机 -u用户名 -p 密码 数据库名 表名 >存储位置
导入
 在登录的情况下：source d:/a.sql
 在没有登录的情况下：mysql -u用户名 -p密码 库名<备份文件

规范数据库设计

三大范式：

第一范式：每个字段不可分

第二范式：每个表只表示一件事

第三范式：表中每一个列都与主键直接相关，不能间接相关

规范和性能

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

性能比规范重要，在考虑性能的基础上，适当考虑规范。

JDBC

为方便开发人员操作数据库，sun公司提供的操作规范，具体规范由数据库厂商提供。

创建测试数据库

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','zhangsan','123456','[email protected]','1980-12-04'),
('2','lisi','123456','[email protected]','1981-12-04'),
('3','wangwu','123456','[email protected]','1979-12-04')

创建一个普通项目

package com.jun.lesson01;

import java.sql.*;

//第一个jdbc程序
public class JdbcFirstDemo {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        // 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.执行SQL对象
        Statement statement = connection.createStatement();
        // 5.执行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("psw="+resultSet.getObject("PASSWORD"));
            System.out.println("email="+resultSet.getObject("email"));
            System.out.println("birthday="+resultSet.getObject("birthday"));
        }
        // 6.释放连接
        resultSet.close();
        statement.close();
        connection.close();
    }
}

connection

connection.rollback();
connection.commit();
connection.setAutoCommit();

statement

statement.executeQuery();//查询操作返回ResultSet
statement.execute();//执行所有的SQL
statement.executeUpdate();//更新，插入，删除，返回一个受影响的行数

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

获得指定的数据类型

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

遍历

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

增

package lesson02.utils;

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) throws SQLException {
        Connection conn=null;
        Statement st=null;
        //ResultSet rs=null;
        try {
             conn = JdbcUtils.getConnection();
             st=conn.createStatement();
             String sql="INSERT INTO users(id,`NAME`,`PASSWORD`,`email`,`birthday`)" +
                     "VALUES (4,'tiantian','123456','[email protected]','2020-01-01')";
             int i=st.executeUpdate(sql);
             if (i>0){
                 System.out.println("插入成功");
             }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.release(conn,st,null);
        }
    }
}

删

package lesson02.utils;




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) throws SQLException {
        Connection conn=null;
        Statement st=null;
        ResultSet rs=null;
        try {
            conn = JdbcUtils.getConnection();
            st=conn.createStatement();
            String sql="DELETE FROM users WHERE id=4";
            int i=st.executeUpdate(sql);
            if (i>0){
                System.out.println("删除成功");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.release(conn,st,rs);
        }
    }
}

改

package lesson02.utils;

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) throws SQLException {
        Connection conn=null;
        Statement st=null;
        ResultSet rs=null;
        try {
            conn = JdbcUtils.getConnection();
            st=conn.createStatement();
            String sql="UPDATE users SET `NAME`='tiantian'WHERE id=1";
            int i=st.executeUpdate(sql);
            if (i>0){
                System.out.println("更新成功");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.release(conn,st,rs);
        }
    }
}

查询

package lesson02.utils;

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 rs=null;
        try {
            conn=JdbcUtils.getConnection();
            st=conn.createStatement();
            String sql="select * from users where id=1";
            rs=st.executeQuery(sql);
            while(rs.next()){
                System.out.println(rs.getString("NAME"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

SQL注入

sql存在漏洞，会被攻击，导致数据泄露。

PreparedStatement对象

可以防止SQL注入，效率更高。

新增

package lesson03;

import 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();
            String sql="insert into users(id,`NAME`,`PASSWORD`,`email`,`birthday`)values(?,?,?,?,?)";
            st=conn.prepareStatement(sql);//预编译sql,先写sql,然后不执行；
            //手动写参数
            st.setInt(1,4);
            st.setString(2,"TIANTIAN");
            st.setString(3,"123456");
            st.setString(4,"[email protected]");
            st.setDate(5,new java.sql.Date(new Date().getTime()));
            int i=st.executeUpdate();
            if (i>0){
                System.out.println("插入成功");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            JdbcUtils.release(conn,st,null);
        }
    }
}

删除

package lesson03;

import lesson02.utils.JdbcUtils;

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

public class TestDelete {
    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);//预编译sql,先写sql,然后不执行；
            //手动写参数
            st.setInt(1,4);
            int i=st.executeUpdate();
            if (i>0){
                System.out.println("删除成功");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            JdbcUtils.release(conn,st,null);
        }
    }
}

更改

package lesson03;

import lesson02.utils.JdbcUtils;

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

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);//预编译sql,先写sql,然后不执行；
            //手动写参数

            st.setString(1,"tianyi");
            st.setInt(2,1);
            int i=st.executeUpdate();
            if (i>0){
                System.out.println("更新成功");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            JdbcUtils.release(conn,st,null);
        }
    }
}

查询

package lesson03;

import lesson02.utils.JdbcUtils;

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

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

        try {
             conn=JdbcUtils.getConnection();
             String sql="select *from users where id=?";
             st=conn.prepareStatement(sql);
             st.setInt(1,2);//传递参数
            rs=st.executeQuery();
            if(rs.next()){
                System.out.println(rs.getString("NAME"));
            }

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