MySQL | 编程好记

一、数据库基本概念

数据库：DateBase，简称：DB

数据库特点：

持久化存储数据 -> 文件系统
方便存储和管理数据
使用了统一方式管理数据库 -> SQL

常见的数据库软件：

Oracle
MySQL
Microsoft SQL Server
DB2
SQLite

二、MySQL

默认端口号：3306

配置环境变量(Mac)：="$PATH":/usr/local/mysql/bin

本地登录

text

mysql -uroot -p密码

指定IP登陆

text

mysql -hIP地址 -uroot -p密码

登出

sql

exit
quit

MySQL目录结构

安装目录
1. bin：*.exe
2. my.ini：MySQL的配置文件
数据目录：数据库(文件夹) -> 表(文件) -> 数据

三、SQL语句

1、基本概念

SQL：结构化查询语言 -> 定义了操作所有关系型数据库的规则

方言：每种数据库操作的方式存在差异

2、SQL语法

SQL语句能单行或多行书写，以分号结尾

不区分大小写，关键字建议大写

注释：

-- 注释内容(必须加空格)
#注释内容：MySQL特有
/*注释内容*/

1）DDL：操作数据库和表

1. 操作数据库：CRUD

Create：创建

sql

-- 创建数据库
create database 数据库名称;
-- 若不存在，创建数据库
create database if not exists 数据库名称;
-- 创建数据库并指定gbk编码
create database 数据库名称 character set gbk;

Retrieve：查询

sql

-- 1.查询所有数据库的名称
show databases;
-- 2.查询某个数据库的创建语句(字符集)
show create database 数据库名称;

Update：修改

sql

-- 修改数据库的字符集
alter database 数据库名称 character set 字符集名称;
alter database db character set utf8;

Delete：删除

sql

-- 删除数据库
drop database 数据库名称;
-- 判断存在再删除数据库
drop database if exists 数据库名称;

2. 使用数据库

sql

-- 1.查询当前正在使用的数据库名称;
select database();
-- 2.使用数据库
use 数据库名称;

3. 操作表

Create：创建

sql

-- 创建表	最后一个不写逗号
create table student(
	id int,
    name varchar(32),
    age int,
    score double(4,1),
    birthday date,
    insert_time timestamp
);

Retrieve：查询

sql

-- 1.查询数据库下表的名称
show 数据库名称;
-- 2.查询表结构
desc 表名;

Update：修改

sql

-- 1.修改表名
alter table 表名 rename to 新的表名;
-- 2.修改表的字符集
alter table 表名 character set 字符集名;
-- 3.添加一列
alter table 表名 add 列名 数据类型;
-- 4.修改列名称 类型
alter table 表名 change 列名 新列名 新数据类型;
-- 5.删除列
alter table 表名 drop 列名;

Delete：删除

sql

drop table 表名;
drop table if exists 表名

4. SQL的数据类型

int：整数类型
double(最大位数, 小数点后位数)：小数类型
date：日期类型（yyyy-MM-dd）
datetime：日期时间类型（yyyy-MM-dd HH:mm:ss）
timestamp：时间戳类型（yyyy-MM-dd HH:mm:ss）（不给赋值会自动用系统时间）
varchar(最大字符数)：字符串

2）DML：数据的增删改

1. 添加数据

sql

insert into 表名(列名1,列名2,...列名n) values (值1,值2,...值n);

列名要和值一一对应可以不写列名进行完全添加

sql

insert into 表名 value (值1,值2,...值n);

除了数字类型，均需要引号

2. 删除数据

sql

delete from 表名 [where 条件];

删除所有元素

sql

delete from 表名;			-- 删除表的所有数据
truncate table 表名;		-- 删除表，并创建新表

3. 修改数据

sql

update 表名 set 列名1 = 值1,列名2 = 值2,...[where 条件];

不加条件会改所有行的数据

3）DQL：数据的查询

1. 基础查询

多个字段的查询

sql

select 字段名1,字段名2... from 表名;
select * from 表名;

去除重复`distinct`

sql

select distinct 字段名 from 表名;

计算列

一般使用四则运算计算列的数值
ifnull(表达式1, 表达式2)
表达式1：可能出现null的列的字段名
表达式2：null的替换值

sql

select name,math,chinese,math + chinese from stu;
select name,math,chinese,ifnull(math + chinese) from stu;

起别名`as`

sql

select name as 姓名 from stu;
select name 姓名 from stu;   -- 可以省略

2. 条件查询

where子句后跟条件

运算符

####### < > <= >= = != < >

sql

select * from stu where age > 20;	-- 大于
select * from stu where age = 20;	-- 等于
select * from stu where age != 20;	-- 不等于
select * from stu where age <> 20;	-- 不等于

####### && (and) || (or) ! (not)

sql

select * from stu where age >= 20 && age <= 30;
select * from stu where age >= 20 and age <= 30;

####### between ... and ...

sql

select * from stu where age between 20 and 30;

####### in(集合)

sql

select * from stu where age = 22 || age = 18 or age = 19;
select * from stu where age in (22,18,19);

####### is null

null值不能使用=判断

sql

select * from stu where math is null;
select * from stu where math is not null;

模糊查询：`like`

占位符

_：单个任意字符
%：多个任意字符

sql

select * from stu where name like '王%';
select * from stu where name like '_铭%';

3. 排序查询

sql

select * from stu order by 排序字段1 排序方式1,排序字段2 排序方式2 ...;

排序方式：

ASC：升序，默认的
DESC：降序

4. 聚合函数

将一列作为整体进行纵向计算

计算个数：count

选非空的列：主键
count(*)

sql

select count(name) from student;

计算最大值：max

sql

select max(math) from student;

计算最小值：min

sql

select min(math) from student;

计算求和：sum

sql

select sum(math) from student;

计算平均值：avg

sql

select avg(math) from student;

ifnull

聚合函数会排除null值

选不包含null的列
ifnull函数

sql

select count(ifnull(name,0)) from student;

计算结果特点：单行单列

5. 分组查询

group by + 分组字段

分组之后查询的字段：分组字段、聚合函数

where和having的区别
限定时间
where在分组前限定，不满足条件不参与分组
having在分组后限定，不满足条件不被查询
聚合函数
where后面能加聚合函数
having后面不能加聚合函数

sql

select sex,avg(math),count(id) from stu group by sex;
select sex,avg(math),count(id) from stu where math >= 70 group by sex;
select sex,avg(math),count(id) from stu where math >= 70 group by sex having count(id) > 2;
select sex,avg(math),count(id) 人数 from stu where math >= 70 group by sex having 人数 > 2;

6. 分页查询

语法： limit 开始的索引, 每页的条数

sql

select * from stu limit 0,3;

开始的索引 = (当前的页码 - 1) * 每页显示的页数

limit是MySQL的"方言"

3、约束

对表的数据进行限定，保证数据的正确性、有效性和完整性

1）非空约束

非空约束not null：值不为null

1. 创建表时添加约束

sql

create table stu(
	id int,
    name varchar(20) not null
);

2. 删除表的约束

sql

alter table stu modify name vachar(20);

3. 后期添加约束

sql

alter table stu modify name vachar(20) not null;

2）唯一约束

唯一约束unique：值不重复
能保存null值，但是只能保存一个

1. 创建表时添加约束

sql

create table stu(
	id int,
    phone varchar(20) unique
);

2. 删除表的约束

sql

alter table stu drop index phone;

3. 后期添加约束

只有在没有重复数据才能添加成功

sql

alter table stu modify phone vachar(20) unique;

3）主键约束

主键约束primary key：非空且唯一

一张表只能有一个主键，是表中记录的唯一标识

1. 创建表时添加约束

sql

create table stu(
	id int primary key,
    phone varchar(20)
);

2. 删除表的约束

sql

alter table stu drop primary key;

3. 后期添加约束

只有在没有重复数据才能添加成功

sql

alter table stu modify id int primary key;

4）自动增长auto_increment

1. 创建表时添加约束

sql

create table stu(
	id int primary key auto_increment,
   phone varchar(20)
);

2. 添加数据

sql

insert into stu value(null,'wmh');

3. 删除自动增长(不影响主键)

sql

alter table stu modify id int;

5）外键约束

外键约束forign key：让表于表产生关系，从而保证数据的正确性

1. 在创建表时，可以添加外键

sql

create table 表名(
	...
    外键列
    constraint 外键名称 foreign key (外键列名称) references 主表名称(主表列名称)
);

2. 删除外键

sql

alter table 表名 drop foreign key 外键名称;

3. 创建表之后，添加外键

sql

alter table 表名 add constraint 外键名称 foreign key (外键字段名称) references 主表名称(主表列名称);

4. 级联操作

添加级联操作

sql

alter table 表名 add constraint 外键名称 foreign key (外键字段名称) on update cascade on delete cascade;

分类

级联更新：on update cascade

级联删除：on delete cascade

四、数据库的设计

1、多表关系

一对多(多对一)：在多的一方建立外键，指向一的一方的主键。
多对多：多对多关系实现需要借助第三张中间表。中间表至少包含两个字段，这两个字段作为第三张表的外键，分别指向两张表的主键
一对一：一对一关系实现，可以在任意一方添加唯一外键指向另一方的主键。

2、数据库设计的范式

1）概述

范式：设计数据库时，需要遵循的一些规范。要遵循后边的范式要求，必须先遵循前边的所有范式要求

2）分类

第一范式（1NF）：每一列都是不可分割的原子数据项
第二范式（2NF）：在1NF的基础上，非码属性必须完全依赖于码（在1NF基础上消除非主属性对主码的部分函数依赖）
第三范式（3NF）：在2NF基础上，任何非主属性不依赖于其它非主属性（在2NF基础上消除传递依赖）

3）概念

函数依赖A -> B,如果通过A属性(属性组)的值，可以确定唯一B属性的值。则称B依赖于A
完全函数依赖：A -> B，如果A是一个属性组，则B属性值得确定需要依赖于A属性组中所有的属性值
部分函数依赖：A -> B，如果A是一个属性组，则B属性值得确定只需要依赖于A属性组中某一些值即可
传递函数依赖：A -> B, B -> C ，如果通过A属性(属性组)的值，可以确定唯一B属性的值，在通过B属性（属性组）的值可以确定唯一C属性的值，则称 C 传递函数依赖于A
码：如果在一张表中，一个属性或属性组，被其他所有属性所完全依赖，则称这个属性(属性组)为该表的码
主属性：码属性组中的所有属性
非主属性：除过码属性组的属性

3、多表查询

1）笛卡尔积

有两个集合A,B，取这两个集合的所有组成情况。

要完成多表查询，需要消除无用的数据

2）内连接查询

1. 隐式内连接

使用where条件消除无用数据

sql

SELECT 
	t1.name, -- 员工表的姓名
	t1.gender,-- 员工表的性别
	t2.name -- 部门表的名称
FROM
	emp t1,
	dept t2
WHERE 
	t1.dept_id = t2.id;

2. 显式内连接

sql

-- 语法
select 字段列表 from 表名1 [inner] join 表名2 on 条件;
-- 例如
SELECT * FROM emp INNER JOIN dept ON emp.dept_id = dept.id;	
SELECT * FROM emp JOIN dept ON emp.dept_id = dept.id;

3. 内连接查询使用思想

从哪些表中查询数据？

条件是什么？

查询哪些字段？

3）外链接查询

1. 左外连接

sql

select 字段列表 from 表1 left [outer] join 表2 on 条件;

查询的是左表所有数据以及其交集部分

2. 右外连接

sql

select 字段列表 from 表1 right [outer] join 表2 on 条件;

查询的是右表所有数据以及其交集部分

4）子查询

根据结果分类

1. 单行单列

子查询可以作为条件，使用运算符判断

sql

select * from stu where age < (select avg(age) from stu);

2. 多行单列

子查询可以作为条件，使用in来判断

sql

select * from stu where id in (select id from class where name = '一班' or name = '二班');

not in

3. 多行多列

虚拟表

sql

select *
from dept t1,(select * 
             from emp 
             where emp.date > '2021-11-11') t2
where
t1.id = t2.dept_id;

普通内连接

sql

select *
from emp t1,dept t2
where t1.dept_id = t2.id and t1.date > '2021-11-11'

4. 自关联查询

sql

SELECT 
	t1.ename,
	t2.ename
FROM emp t1
LEFT JOIN emp t2
on t1.mgr = t2.id;

4、事务

1）事务概念

1. 概念

如果一个包含多个步骤的业务操作，被事务管理，要么同时成功，要么同时失败

2. 操作

开始事务：start transaction;

回滚：rollback;

提交：commit;

3. 事务默认提交

Oracle默认手动提交

一条DML(增删改)语句会自动提交一次事务

修改事务的默认提交方式：

sql

-- 查询
select @@autocommit;	-- 自动：1；手动：0
-- 修改
select @@autocommit = 0;

2）事务的四大特征

原子性：是不可分割的最小操作单位，要么同时成功，要么失败
持久性：事务结束后，数据库会持久的保存数据
隔离性：多个事务之间相互独立
一致性：事务操作前后，数据总量不变

3）事务的隔离级别

1. 概念

多个事务之间相互独立，但是多个事务操作同一批数据，会引发问题，设置不同的隔离级别可以解决这些问题

2. 问题

脏读：一个事务读取到另一个事务没有提交的数据
虚读（不可重复读）：在同一个事务中两次读取的数据不一样
幻读：一个事务操作表中的所有记录，另一个事务添加了一条数据，第一个事务查不到自己的修改

3. 隔离级别

read uncommitted：读未提交 -->脏读、虚读、幻读
read committed：读已提交（Oracle默认）--> 虚读、幻读
repeatable read：可重复读（MySQL默认）--> 幻读
serializable：串行化 --> 没问题

隔离级别从小到大安全性越来越高，但是效率越来越低

sql

-- 隔离级别的查询和设置
-- 查询
select @@tx_isolation;
-- 设置
set global transaction isolation level 级别字符串;

5、DCL：管理用户、授权

DBA：数据库管理员

1）管理用户

1. 添加用户

sql

use mysql;
create user '用户名'@'主机名' identified by '密码';

2. 删除用户

sql

use mysql;
drop user '用户名'@'主机名';

3. 修改密码

sql

update user set password = password('新密码') where user = '用户名';
set password for '用户名'@'主机名' = password('新密码');

4. root用户密码忘记

cmd -> net stop mysql (需要管理员运行)

使用无验证方式启动mysqlmysqld --skip-grant-tables

修改密码

关闭mysqld服务

5. 查询用户

sql

-- 1.切换到mysql数据库
use mysql;
-- 2.查询user表
select * from user;

通配符%：可以在任意主机上登陆

2）权限管理

1. 查询权限

sql

show grants for '用户名'@'主机名';

2. 授予权限

sql

grant 权限列表 on 数据库名.表名 to '用户名'@'主机名';
grant all on *.* to 'wmh'@'%';	-- 授予root权限

3. 撤销权限

sql

revoke 权限列表 on 数据库名.表名 from '用户名'@'主机名';

五、JDBC

1、JDBC概述

概念：Java DataBase ConnectivityJava 数据库连接，Java语言操作数据库

JDBC本质：一套操作所有关系型数据库的规则(接口)，各个数据库厂商去实现这套接口，提供数据库驱动jar包。我们可以使用这套接口（JDBC）进行编程，真正执行的代码是驱动jar包中的实现类。

2、JDBC的使用

1）使用方法

导入驱动jar包
1. 复制到项目libs目录下
2. 右键 --> Add As Library
注册驱动
获取数据库连接对象 Connection
定义sql
获取执行sql语句的对象 Statement
执行sql，接收返回结果
处理结果
释放资源

java

//1.导包
//2.注册驱动
Class.forName("com.mysql.jdbc.Driver");
//3.获取数据库连接对象
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test","root","root");
//4.定义sql
String sql = "update stu set age = 18 where id = 1";
//5.获取执行sql的对象
Statement stmt = conn.createStatement();
//6.执行sql
int count = stmt.executeUpdate(sql);
//7.处理结果
System.out.printIn(count);
//8.释放资源
stmt.close();
conn.close();

2）详解各个对象

1. DriverManager：驱动管理对象

注册驱动：告诉程序该使用哪一个数据库驱动jar

java

Class.forName("com.mysql.jdbc.Driver");
//溯源：在com.mysql.jdbc.Driver类中存在静态代码块
static {
    try {			      
        java.sql.DriverManager.registerDriver(new Driver());
    } catch (SQLException E) {
        throw new RuntimeException("Can't register driver!");
    }
}

mysql5之后的驱动jar包可以省略注册驱动的步骤

获取数据库连接

java

//方法
static Connection getConnection(String url, String user, String password)；

url：连接的路径
1. 语法：jdbc:mysql://ip地址(域名):端口号/数据库名称
2. 本机mysql且端口，可简写：jdbc:mysql:///数据库名称
user：用户名
password：密码

2. Connection：数据库连接对象

获取执行sql的对象
1. Statement createStatement()
2. PreparedStatement prepareStatement(String sql)
管理事务
开启事务：setAutoCommit(boolean autoCommit) 调用该方法设置参数为false，即开启事务
提交事务：commit()
回滚事务：rollback()

3. Statement：执行sql的对象

boolean execute(String sql) ：可以执行任意的sql (了解)

int executeUpdate(String sql) ：执行DML(insert、update、delete)语句、DDL(create，alter、drop)语句（返回值：影响的行数，可以通过这个影响的行数判断DML语句是否执行成功返回值>0的则执行成功，反之，则失败。）

ResultSet executeQuery(String sql) ：执行DQL(select)语句

4. ResultSet：结果集对象,封装查询结果

boolean next()：游标向下移动一行，判断当前行是否是最后一行末尾(是否有数据)，如果是，则返回false，如果不是则返回true

getXxx(参数)：获取数据

Xxx：代表数据类型如： int getInt() , String getString()
参数：
1. int：代表列的编号,从1开始如： getString(1)
2. String：代表列名称。如： getDouble("balance")
使用步骤：
1. 游标向下移动一行
2. 判断是否有数据
3. 获取数据

5. PreparedStatement：执行sql的预编译对象

SQL注入问题：在拼接sql时，有一些sql的特殊关键字参与字符串的拼接。会造成安全性问题

参数使用?作为占位符

使用：

定义sql：select * from user where username = ? and password = ?;
获取sql预编译对象：PreparedStatement Connection.prepareStatement(String sql);
给?赋值：setXxx(参数1,参数2)
1. Xxx：代表数据类型如： int getInt() , String getString()
2. 参数1：?的位置编号从1开始
3. 参数2：?的值
执行sql，接受返回结果，不需要传递sql语句

后期都会使用PreparedStatement来完成增删改查的所有操作

可以防止SQL注入
效率更高

3、JDBC工具类

properties

#jdbc.properties
url=
user=
password=

java

public class JDBCUtils {
    private static String url;
    private static String user;
    private static String password;
    private static String driver;
    /**
     * 文件的读取，只需要读取一次即可拿到这些值-->使用静态代码块
     */
    static{
        //读取资源文件，获取值。
        try {
            //1. 创建Properties集合类。
            Properties pro = new Properties();

            //获取src路径下的文件的方式--->ClassLoader 类加载器
            ClassLoader classLoader = JDBCUtils.class.getClassLoader();
            URL res  = classLoader.getResource("jdbc.properties");
            String path = res.getPath();
            System.out.println(path);
            
            //2. 加载文件
            pro.load(new FileReader(path));

            //3. 获取数据，赋值
            url = pro.getProperty("url");
            user = pro.getProperty("user");
            password = pro.getProperty("password");
            driver = pro.getProperty("driver");
            
            //4. 注册驱动
            Class.forName(driver);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 获取连接
     */
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url, user, password);
    }

    /**
     * 释放资源
     */
    public static void close(Statement stmt,Connection conn){
        JDBCUtils.close(null,stmt,conn);
    }
    
    /**
     * 释放资源
     */
    public static void close(ResultSet rs,Statement stmt, Connection conn){
        if( rs != null){
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if( stmt != null){
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if( conn != null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

4、数据库连接池

概念：一个存放数据库连接的容器，可以节约资源且高效地访问数据库

标准接口(经典白学)

获取连接：getConnection()
归还连接：Connection.close()

数据库厂商接口 => 数据库连接池技术

C3P0
Druid:阿里提供的

1）C3P0

1. 步骤

导入jar包 (两个)： c3p0-0.9.5.2.jar mchange-commons-java-0.2.12.jar 不要忘记导入数据库驱动jar包
定义配置文件：
名称：c3p0.properties 或者 c3p0-config.xml
路径：直接将文件放在src目录下即可
创建核心对象数据库连接池对象：ComboPooledDataSource
获取连接：getConnection

2. 代码实现

java

//1.创建数据库连接池对象
DataSource ds  = new ComboPooledDataSource();
//2. 获取连接对象
Connection conn = ds.getConnection();

2）Druid

导入jar包 druid-1.0.9.jar
定义配置文件：properties形式、可以叫任意名称，可以放在任意目录下
加载配置文件：Properties
获取数据库连接池对象：通过工厂来来获取 DruidDataSourceFactory
获取连接：getConnection

java

//3.加载配置文件
Properties pro = new Properties();
InputStream is = DruidDemo.class.getClassLoader().getResourceAsStream("druid.properties");
pro.load(is);
//4.获取连接池对象
DataSource ds = DruidDataSourceFactory.createDataSource(pro);
//5.获取连接
Connection conn = ds.getConnection();

3）Druid工具类

java

public class JDBCUtils {

    //1.定义成员变量 DataSource
    private static DataSource ds ;

    static{
        try {
            //1.加载配置文件
            Properties pro = new Properties();
            pro.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
            
            //2.获取DataSource
            ds = DruidDataSourceFactory.createDataSource(pro);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

  /**
	* 获取连接
	*/
    public static Connection getConnection() throws SQLException {
        return ds.getConnection();
    }

  /**
	* 释放资源
	*/
    public static void close(Statement stmt,Connection conn){
        /* if(stmt != null){
		            try {
		                stmt.close();
		            } catch (SQLException e) {
		                e.printStackTrace();
		            }
		        }

		        if(conn != null){
		            try {
		                conn.close();//归还连接
		            } catch (SQLException e) {
		                e.printStackTrace();
		            }
		        }
		*/
        close(null,stmt,conn);
    }
    public static void close(ResultSet rs , Statement stmt, Connection conn){
        if(rs != null){
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(stmt != null){
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if(conn != null){
            try {
                conn.close();//归还连接
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

  /**
	* 获取连接池方法
	*/

    public static DataSource getDataSource(){
        return  ds;
    }
}

5、Spring JDBC

1）概述

Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发

2）步骤

导入jar包
创建JdbcTemplate对象。依赖于数据源DataSource：JdbcTemplate template = new JdbcTemplate(ds);
调用JdbcTemplate的方法来完成CRUD的操作

2）方法

update()：执行DML语句。增、删、改语句

queryForMap()：查询结果将结果集封装为map集合，将列名作为key，将值作为value 将这条记录封装为一个map集合 --> 这个方法查询的结果集长度只能是1

queryForList()：查询结果将结果集封装为list集合 --> 将每一条记录封装为一个Map集合，再将Map集合装载到List集合中

query()：查询结果，将结果封装为JavaBean对象

query的参数：RowMapper
一般我们使用BeanPropertyRowMapper实现类。可以完成数据到JavaBean的自动封装
new BeanPropertyRowMapper<类型>(类型.class)

java

@Test
public void test(){
    String sql = "select * from emp";
    List<Emp> list = template.query(sql, new BeanPropertyRowMapper<Emp>(Emp.class));
    for (Emp emp : list) {
        System.out.println(emp);
    }
}

queryForObject：查询结果，将结果封装为对象 => 一般用于聚合函数的查询

java

@Test
public void test(){
  String sql = "select count(id) from emp";
  Long total = template.queryForObject(sql, Long.class);
  System.out.println(total);
}

一、数据库基本概念 ​

二、MySQL ​

三、SQL语句 ​

1、基本概念 ​

2、SQL语法 ​

1）DDL：操作数据库和表 ​

1. 操作数据库：CRUD ​

Create：创建 ​

Retrieve：查询 ​

Update：修改 ​

Delete：删除 ​

2. 使用数据库 ​

3. 操作表 ​

Create：创建 ​

Retrieve：查询 ​

Update：修改 ​

Delete：删除 ​

4. SQL的数据类型 ​

2）DML：数据的增删改 ​

1. 添加数据 ​

2. 删除数据 ​

3. 修改数据 ​

3）DQL：数据的查询 ​

1. 基础查询 ​

多个字段的查询 ​

去除重复distinct ​

计算列 ​

起别名as ​

2. 条件查询 ​

where子句后跟条件 ​

运算符 ​

模糊查询：like ​

3. 排序查询 ​

4. 聚合函数 ​

计算个数：count ​

计算最大值：max ​

计算最小值：min ​

计算求和：sum ​

计算平均值：avg ​

ifnull ​

5. 分组查询 ​

6. 分页查询 ​

3、约束 ​

1）非空约束 ​

1. 创建表时添加约束 ​

2. 删除表的约束 ​

3. 后期添加约束 ​

2）唯一约束 ​

1. 创建表时添加约束 ​

2. 删除表的约束 ​

3. 后期添加约束 ​

3）主键约束 ​

1. 创建表时添加约束 ​

2. 删除表的约束 ​

3. 后期添加约束 ​

4）自动增长auto_increment ​

1. 创建表时添加约束 ​

2. 添加数据 ​

3. 删除自动增长(不影响主键) ​

5）外键约束 ​

1. 在创建表时，可以添加外键 ​

2. 删除外键 ​

3. 创建表之后，添加外键 ​

4. 级联操作 ​

添加级联操作 ​

分类 ​

四、数据库的设计 ​

1、多表关系 ​

2、数据库设计的范式 ​

1）概述 ​

2）分类 ​

3）概念 ​

3、多表查询 ​

1）笛卡尔积 ​

2）内连接查询 ​

1. 隐式内连接 ​

2. 显式内连接 ​

3. 内连接查询使用思想 ​

3）外链接查询 ​

1. 左外连接 ​

一、数据库基本概念

二、MySQL

三、SQL语句

1、基本概念

2、SQL语法

1）DDL：操作数据库和表

1. 操作数据库：CRUD

Create：创建

Retrieve：查询

Update：修改

Delete：删除

2. 使用数据库

3. 操作表

Create：创建

Retrieve：查询

Update：修改

Delete：删除

4. SQL的数据类型

2）DML：数据的增删改

1. 添加数据

2. 删除数据

3. 修改数据

3）DQL：数据的查询

1. 基础查询

多个字段的查询

去除重复`distinct`

计算列

起别名`as`

2. 条件查询

where子句后跟条件

运算符

模糊查询：`like`

3. 排序查询

4. 聚合函数

计算个数：count

计算最大值：max

计算最小值：min

计算求和：sum

计算平均值：avg

ifnull

5. 分组查询

6. 分页查询

3、约束

1）非空约束

1. 创建表时添加约束

2. 删除表的约束

3. 后期添加约束

2）唯一约束

1. 创建表时添加约束

2. 删除表的约束

3. 后期添加约束

3）主键约束

1. 创建表时添加约束

2. 删除表的约束

3. 后期添加约束

4）自动增长auto_increment

1. 创建表时添加约束

2. 添加数据

3. 删除自动增长(不影响主键)

5）外键约束

1. 在创建表时，可以添加外键

2. 删除外键

3. 创建表之后，添加外键

4. 级联操作

添加级联操作

分类

四、数据库的设计

1、多表关系

2、数据库设计的范式

1）概述

2）分类

3）概念

3、多表查询

1）笛卡尔积

2）内连接查询

1. 隐式内连接

2. 显式内连接

3. 内连接查询使用思想

3）外链接查询

1. 左外连接