MySQL是一个关系型数据库管理系统，由瑞典MySQL AB 公司开发，属于 Oracle 旗下产品。MySQL 是最流行的关系型数据库管理系统之一，在 WEB 应用方面，MySQL是最好的 RDBMS (Relational Database Management System，关系数据库管理系统) 应用软件之一。

数据库概念

数据库（Database）是按照数据结构来组织、存储和管理数据的仓库。

每个数据库都有一个或多个不同的 API 用于创建，访问，管理，搜索和复制所保存的数据。

我们也可以将数据存储在文件中，但是在文件中读写数据速度相对较慢。

所以，现在我们使用关系型数据库管理系统（RDBMS）来存储和管理大数据量。所谓的关系型数据库，是建立在关系模型基础上的数据库，借助于集合代数等数学概念和方法来处理数据库中的数据。

RDBMS 即关系数据库管理系统(Relational Database Management System)的特点：

1. 数据以表格的形式出现

2. 每行为各种记录名称

3. 每列为记录名称所对应的数据域

4. 许多的行和列组成一张表单

5. 若干的表单组成database

数据库语言分为四大类

• 数据定义语言(DDL)，例如：CREATE、DROP、ALTER等语句。

• 数据操作语言(DML)，例如：INSERT（插入）、UPDATE（修改）、DELETE（删除）语句。

• 数据查询语言(DQL)，例如：SELECT语句。（一般不会单独归于一类，因为只有一个语句）。

• 数据控制语言(DCL)，例如：GRANT、REVOKE等语句。

PS：事务控制语言（TCL），例如：COMMIT、ROLLBACK等语句。

Mysql简介

MySQL是一个关系型数据库管理系统，由瑞典MySQL AB 公司开发，属于 Oracle 旗下产品。MySQL 是最流行的关系型数据库管理系统之一，在 WEB 应用方面，MySQL是最好的 RDBMS (Relational Database Management System，关系数据库管理系统) 应用软件之一。

MySQL是一种关系型数据库管理系统，关系数据库将数据保存在不同的表中，而不是将所有数据放在一个大仓库内，这样就增加了速度并提高了灵活性。

MySQL所使用的 SQL 语言是用于访问数据库的最常用标准化语言。MySQL 软件采用了双授权政策，分为社区版和商业版，由于其体积小、速度快、总体拥有成本低，尤其是开放源码这一特点，一般中小型网站的开发都选择 MySQL 作为网站数据库。

MySQL 事务

MySQL 事务主要用于处理操作量大，复杂度高的数据。比如说，在人员管理系统中，你删除一个人员，你既需要删除人员的基本资料，也要删除和该人员相关的信息，如信箱，文章等等，这样，这些数据库操作语句就构成一个事务！

在 MySQL 中只有使用了 Innodb 数据库引擎的数据库或表才支持事务。

事务处理可以用来维护数据库的完整性，保证成批的 SQL 语句要么全部执行，要么全部不执行。

事务用来管理 insert,update,delete 语句

一般来说，事务是必须满足4个条件（ACID）：：原子性（Atomicity，或称不可分割性）、一致性（Consistency）、隔离性（Isolation，又称独立性）、持久性（Durability）。

• 原子性：一个事务（transaction）中的所有操作，要么全部完成，要么全部不完成，不会结束在中间某个环节。事务在执行过程中发生错误，会被回滚（Rollback）到事务开始前的状态，就像这个事务从来没有执行过一样。

• 一致性：在事务开始之前和事务结束以后，数据库的完整性没有被破坏。这表示写入的资料必须完全符合所有的预设规则，这包含资料的精确度、串联性以及后续数据库可以自发性地完成预定的工作。

• 隔离性：数据库允许多个并发事务同时对其数据进行读写和修改的能力，隔离性可以防止多个事务并发执行时由于交叉执行而导致数据的不一致。事务隔离分为不同级别，包括读未提交（Read uncommitted）、读提交（read committed）、可重复读（repeatable read）和串行化（Serializable）。

• 持久性：事务处理结束后，对数据的修改就是永久的，即便系统故障也不会丢失。

下载地址

MySQL :: Download MySQL Community Server (Archived Versions)

在输入栏中搜索5.5.49的版本下载即可（当然不限制其他版本）

Mysql命令

创建数据库

CREATE DATABASE world

删除数据库

DROP DATABASE db_librarysys

使用数据库

use world

查找所有数据库

SHOW DATABASES;

数据表操作

创建数据表

CREATE TABLE USER(
    id INT NOT NULL AUTO_INCREMENT,
    username VARCHAR(20),
    PASSWORD VARCHAR(20),
    PRIMARY KEY (`id`)
)

删除数据表

DROP TABLE user

查找所有数据表

SHOW TABLES;

查看当前表结构

SHOW COLUMNS FROM tb; 

tb为表格名字

数据操作

插入数据

INSERT INTO user (username, password) VALUES ('1234', '1234'); //单条数据

INSERT INTO user (username, password) VALUES ('1234', '1234'),('123', '134'); //批量数据

更改数据

update user set username='1234' where id='1234';

删除数据

DELETE FROM user WHERE username = '1234'

查询数据

where：数据库中常用的是where关键字，用于在初始表中筛选查询。它是一个约束声明，用于约束数据，在返回结果集之前起作用。

group by:对select查询出来的结果集按照某个字段或者表达式进行分组，获得一组组的集合，然后从每组中取出一个指定字段或者表达式的值。

having：用于对where和group by查询出来的分组经行过滤，查出满足条件的分组结果。它是一个过滤声明，是在查询返回结果集以后对查询结果进行的过滤操作。

执行顺序

select –>where –> group by–> having–>order by

全部查询

SELECT * from user

精准查询

SELECT * from user WHERE username='1234';

模糊查询

在 where like 的条件查询中，SQL 提供了四种匹配方式。

1. %：表示任意 0 个或多个字符。可匹配任意类型和长度的字符，有些情况下若是中文，请使用两个百分号（%%）表示。

2. _：表示任意单个字符。匹配单个任意字符，它常用来限制表达式的字符长度语句。

3. []：表示括号内所列字符中的一个（类似正则表达式）。指定一个字符、字符串或范围，要求所匹配对象为它们中的任一个。

4. [^] ：表示不在括号所列之内的单个字符。其取值和 [] 相同，但它要求所匹配对象为指定字符以外的任一个字符。 查询内容包含通配符时,由于通配符的缘故，导致我们查询特殊字符 “%”、“_”、“[” 的语句无法正常实现，而把特殊字符用 “[ ]” 括起便可正常查询。

SELECT * from user WHERE username LIKE '%4' //以4结尾的匹配

like 匹配/模糊匹配，会与 % 和 _ 结合使用。

• '%a'：以a结尾的数据

• 'a%'：以a开头的数据

• '%a%'：含有a的数据

• '_a_'：三位且中间字母是a的

• '_a'：两位且结尾字母是a的

• 'a_'：两位且开头字母是a的

联合查询

作用为：

1. 集合两个表中相同的元素

2. 单个表执行多个查询

3. 拼接多条select语句

SELECT id FROM city UNION SELECT id FROM usertable

排序查询

SELECT * from city ORDER BY id ASC

• ASC 升序(默认)

• DESC 降序

分组查询

SELECT name, COUNT(*) FROM city GROUP BY name;

连接查询

可以在 SELECT, UPDATE 和 DELETE 语句中使用 Mysql 的 JOIN 来联合多表查询。

JOIN 按照功能大致分为如下三类：

• INNER JOIN（内连接,或等值连接）：获取两个表中字段匹配关系的记录。

• LEFT JOIN（左连接）：获取左表所有记录，即使右表没有对应匹配的记录。

• RIGHT JOIN（右连接）： 与 LEFT JOIN 相反，用于获取右表所有记录，即使左表没有对应匹配的记录。

内连接：

SELECT a.name, a.age, b.username FROM a INNER JOIN b ON a.id = b.id

等价于

SELECT a.name, a.age, b.username FROM a, b WHERE a.id = b.id

外连接（左连接）：

SELECT a.name, a.age, b.username FROM a LEFT JOIN b ON a.id = b.id

外连接（右连接）：

SELECT a.name, a.age, b.username FROM a RIGHT JOIN b ON a.id = b.id

Mysql内置函数

源自：MySQL函数大全，MySQL常用函数汇总 (biancheng.net)

聚合函数

日期和时间函数

字符串函数

数值型函数

流程控制函数

计算机语言连接mysql

java

java有多种框架支撑，但是基本套路都是【驱动+连接+事务】，这里用mysql-connector-java（5.1.40）作为驱动，mybatis作为事务框架。何为事务，网上有各种教材，但笔者认为，事务用最简单的概括即是增删查改。

JDBC

作为最原始的JDBC，没有用事务框架，用ResultSet处理数据库的数据（查），PreparedStatement进行事务操作（增删改），使用mysql-connector-java作为mysql驱动，引入jar包或者依赖即可

import java.sql.*;
 
public class MySQLDemo {
 
    // MySQL 8.0 以下版本 - JDBC 驱动名及数据库 URL
    static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";  
    static final String DB_URL = "jdbc:mysql://localhost:3306/RUNOOB";
 
    // MySQL 8.0 以上版本 - JDBC 驱动名及数据库 URL
    //static final String JDBC_DRIVER = "com.mysql.cj.jdbc.Driver";  
    //static final String DB_URL = "jdbc:mysql://localhost:3306/RUNOOB?useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=UTC";
 
 
    // 数据库的用户名与密码，需要根据自己的设置
    static final String USER = "root";
    static final String PASS = "123456";
 
    public static void main(String[] args) {
        Connection conn = null;
        Statement stmt = null;
        try{
            // 注册 JDBC 驱动
            Class.forName(JDBC_DRIVER);
        
            // 打开链接
            System.out.println("连接数据库...");
            conn = DriverManager.getConnection(DB_URL,USER,PASS);
        
            // 执行查询
            System.out.println("实例化Statement对象...");
            stmt = conn.createStatement();
            String sql;
            sql = "SELECT id, name, url FROM websites";
            ResultSet rs = stmt.executeQuery(sql);
        
            // 展开结果集数据库
            while(rs.next()){
                // 通过字段检索
                int id  = rs.getInt("id");
                String name = rs.getString("name");
                String url = rs.getString("url");
    
                // 输出数据
                System.out.print("ID: " + id);
                System.out.print(", 站点名称: " + name);
                System.out.print(", 站点 URL: " + url);
                System.out.print("\n");
            }
            // 完成后关闭
            rs.close();
            stmt.close();
            conn.close();
        }catch(SQLException se){
            // 处理 JDBC 错误
            se.printStackTrace();
        }catch(Exception e){
            // 处理 Class.forName 错误
            e.printStackTrace();
        }finally{
            // 关闭资源
            try{
                if(stmt!=null) stmt.close();
            }catch(SQLException se2){
            }// 什么都不做
            try{
                if(conn!=null) conn.close();
            }catch(SQLException se){
                se.printStackTrace();
            }
        }
        System.out.println("Goodbye!");
    }
}

其中ps的操作为：

//3.获得预处理对象
String sql = "update sort set sname=? where sid=?";
PreparedStatement stat = con.prepareStatement(sql);
//4.SQL语句占位符设置实际参数
stat.setString(1, "test");//索引参数1代表着sql中的第一个？号，也就是我需要将条件sid所对应的sname数据更新为“儿童玩具测试”
stat.setInt(2, 3);//索引参数2代表着sql中的第二个？号，也就是条件是sid为3
//5.执行SQL语句
int line = stat.executeUpdate();
System.out.println("更新记录数"+ line);
//6.释放资源
stat.close();

mybatis

orm工具的基本思想

无论是用过的hibernate,mybatis,你都可以观察到他们有一些共同点：

• 从配置文件(通常是XML配置文件中)得到 sessionfactory.

• 由sessionfactory 产生 session

• 在session 中完成对数据的增删改查和事务提交等.

• 在用完之后关闭session 。

• 在java 对象和 数据库之间有做mapping 的配置文件，也通常是xml 文件。

Mybatis的功能架构分为三层：

1. API接口层：提供给外部使用的接口API，开发人员通过这些本地API来操纵数据库。接口层一接收到调用请求就会调用数据处理层来完成具体的数据处理。

2. 数据处理层：负责具体的SQL查找、SQL解析、SQL执行和执行结果映射处理等。它主要的目的是根据调用的请求完成一次数据库操作。

3. 基础支撑层：负责最基础的功能支撑，包括连接管理、事务管理、配置加载和缓存处理，这些都是共用的东西，将他们抽取出来作为最基础的组件。为上层的数据处理层提供最基础的支撑。

首先引入依赖：

<!--导入依赖-->
<dependencies>
    <!--mysqlq驱动-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.40</version>
    </dependency>
    <!--mybatis-->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.4</version>
    </dependency>
</dependencies>

编写mybatis的核心配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--configuration核心配置文件-->
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/test?userSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
</configuration>

编写mybatis工具类

//sqlSessionFactory --> sqlSession
public class MybatisUtils {

    static SqlSessionFactory sqlSessionFactory = null;

    static {
        try {
            //使用Mybatis第一步 ：获取sqlSessionFactory对象
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //既然有了 SqlSessionFactory，顾名思义，我们可以从中获得 SqlSession 的实例.
    // SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。
    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession();
    }
}

Dao

public interface UserDao {
    public List<User> getUserList();
}

Mapper映射文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<!--namespace=绑定一个指定的Dao/Mapper接口-->
<mapper namespace="com.test.dao.UserDao">
    <select id="getUserList" resultType="com.test.pojo.User">
    select * from USER
  </select>
</mapper>

使用

//1.获取SqlSession对象
SqlSession sqlSession = MybatisUtils.getSqlSession();
//2.执行SQL
// 方式一：getMapper
UserDao userDao = sqlSession.getMapper(UserDao.class);
List<User> userList = userDao.getUserList();
for (User user : userList) {
    System.out.println(user);
}

//关闭sqlSession
sqlSession.close();

springboot

大概思路为：引入依赖【驱动，事务框架】--> 修改连接参数【application.yml】--> 添加映射xml，并添加sql语句 --> 添加pojo对象，存储数据 --> 添加映射类映射sql语句【CURD操作】

首先引入依赖：

<!-- mysql驱动 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.40</version>
</dependency>
<!-- mybatis starter -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.4</version>
</dependency>
<!-- mybatis starter -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.4</version>
</dependency>

修改application.yml，为数据库的连接提供参数

spring:
  datasource:
    # UTC： Coordinated Universal Time, 国际协调时间，也称世界标准时间。
    # 设置国际标准时间能够保证mysql连接不会出现时区错误，并且保证编号为UTF-8
    url: jdbc:mysql://localhost:3306/test?characterEncoding=utf-8&serverTimezone=UTC
    username: root
    password: 1234
    driver-class-name: com.mysql.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource
mybatis:
  mapper-locations: classpath:/mapper/*Mapper.xml # mapper文件存放位置
  type-aliases-package: com.test.dao # mapper配置类存放包

在resources文件夹下添加mapper文件夹，并添加Test01Mapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 命名空间映射到Mapper的该config类 -->
<mapper namespace="com.test.Mapper.Test01MapperDao">
    <select id="queryList" resultType="com.test.pojo.test01">
        SELECT * FROM test01;
    </select>

    <select id="queryById" resultType="com.test.pojo.test01" parameterType="Integer">
        SELECT * FROM test01 WHERE id = #{id};
    </select>

    <insert id="add" parameterType="com.test.pojo.test01">
        INSERT INTO test01 ('username', 'password', 'type', 'number') VALUES (#{username}, #{password}, #{type}, #{number});
    </insert>
    
    <update id="update" parameterType="com.test.pojo.test01">
        UPDATE test01 SET username = #{username},password = #{password},type = #{type},number = #{number}WHERE id = #{id};
    </update>

    <delete id="deleteById" parameterType="Integer">
        DELETE FROM test01 WHERE id = #{id};
    </delete>
</mapper>

添加pojo【test01】，包名为com.test.pojo

package com.test.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/*
 * @Data注解在类上，会为类的所有属性自动生成setter/getter、equals、canEqual、hashCode、toString方法，
 * 如为final属性，则不会为该属性生成setter方法。
 */
@Data
/*
 * 无参构造器、部分参数构造器、全参构造器。Lombok没法实现多种参数构造器的重载。
 */
@NoArgsConstructor
@AllArgsConstructor
public class test01 {
    private int id;
    private String username;
    private String password;
    private String type;
    private int number;
}

以上的属性（id，username，password等）可以用lombok的工具类来添加，一般是用getter和setter来解决。如何生成getter和setter请自行百度。

生成映射类，用于映射.xml文件

package com.test.Mapper;

import org.apache.ibatis.annotations.Mapper;
import com.test.pojo.test01;

import java.util.List;

@Mapper
public interface Test01MapperDao {
    List<test01> queryList();
    test01 queryById(int id);
    int add(test01 info);
    int update(test01 info);
    int deleteById(int id);
}

之后在controller中直接使用该映射类即可。

@RestController
public class MybatisTestController {

    @Autowired
    private Test01MapperDao test01MapperDao;

    @GetMapping("/query")
    public List<test01> query(){
        List<test01> test01 = test01MapperDao.queryList();
        return test01;
    }

    @PostMapping("/queryByid")
    public test01 queryById(@Param("id")Integer id){
        test01 test01;
        if(id != null){
            test01 = test01MapperDao.queryById(id);
        }else{
            test01 = test01MapperDao.queryById(1);
        }
        return test01;
    }

    @PostMapping("/deleteById")
    public String deleteById(@Param("id")Integer id){
        test01MapperDao.deleteById(id);
        return "success";
    }

    @PostMapping("/index")
    public String index(){
        return "hello";
    }
}

python

使用pymysql连接mysql，注意，这里用的是python3，python2是mysqldb，由于python3逐渐成熟，所以python2的mysqldb不再阐述

安装

pip install PyMySQL

引用

import pymysql

连接数据库

db = pymysql.connect(host="localhost",user="username",password="password",database="database") # 打开链接

注意，一定要加上“host=”等字样，否则会出现takes 1 positional argument but 5 were given错误

创建游标对象

cursor = db.cursor()

查询

传输sql语句 --> 查找对象 --> 返回元组（类似list，但是内容不可修改）

cursor.execute("SELECT * FROM table1")# 输入sql语句
results = cursor.fetchall()# 查找所有对象
输出：
((1, 'testing', 'testing', 'test', 'test'),)
results = cursor.fetchone()# 查询一条数据
输出：
(1, 'testing', 'testing', 'test', 'test')

增加一条数据

sql = """INSERT INTO answertable1(name,name2, name3, name4) VALUES ('test01', 'test01', 'test01', 'test01')"""# SQL 插入语句，"""为三引号
cursor.execute(sql)# 执行sql语句
db.commit()# 提交到数据库执行

更新操作

sql = "UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = '%c'" % ('M')# SQL 插入语句
cursor.execute(sql)# 执行sql语句
db.commit()# 提交到数据库执行

删除

sql = "DELETE FROM EMPLOYEE WHERE AGE > %s" % (20)# SQL 插入语句
cursor.execute(sql)# 执行sql语句
db.commit()# 提交到数据库执行

回滚

db.rollback() # 如果发生错误则回滚

关闭数据库

db.close()