MySQL数据库

一，安装数据库5.7.26版本

MySQL安装配置教程 （手把手保姆级安装）_mysql5.7.26安装教程-CSDN博客

使用Navicat  for MySQL，phpstudy_pro辅助工具

二，基本语法

注释：

单行 -- 或#；多行/*    */;

SQL分类：

    DDL:操作数据库，表等；DML:对表中的数据进行增删改；
    DQL:对表中的数据进行查询；DCL:对数据库进行权限控制；

    DDL：

   ---操作数据库

    1.查询 ：show databases；
    2.直接创建： create database ‘数据库名称’ ；

  //判断是否存在，无则创建  create database if not exists ‘数据库名称’
    删除 drop database ‘数据库名称’

  //  判断，如存在则删除  drop database if exists ‘数据库名称’

使用数据库  查看当前使用的数据库 select database()    使用数据库 use 数据库名称         

     ---操作表

    查询表   查询当前数据库下所有表名称 show tables; 查询表结构 desd 表名称；
    创建表   creata table 表名 (
        字段名1： 数据类型1,  id  int,
        字段名2： 数据类型2,  username varchar(30),
        ...
        );
        数据类型：数值类型，日期和时间类型，字符串类型
    删除表   删除表 drop table 表名； 删除表时判断是否存在  drop table if exists 表名
    修改表      修改表名 alter table 表名 rename to 新的表名；
        添加一列  alter table 表名 add 列名 数据类型；
        修改数据类型  alter table 表名 modify 列名 新数据类型；
        修改列名和数据类型  alter table 表名 change 列名 新列名 新数据类型；
        删除列 alter table 表名 drop 列名；

DML:       添加数据   

给指定列表添加数据 insert into 表名（列名1，列名2，...）values(值1，值2，...);
        给全部列表添加数据  insert into 表名 values (值1，值2，...);
        批量添加数据   insert into 表名（列名1，列名2，...）values (值1，值2，...),(值1，值2，...),(值1，值2，...)...;
                   insert into 表名 values(值1，值2，...),(值1，值2，...),(值1，值2，...),,,;
    修改数据   update 表名 set 列名1=值1，列名2=值2，...[while 条件]；
        update stu set sex = '女' while name = '张三'；
        修改语句中不添加条件，则将所有数据都修改
    删除数据   delete from 表名 [while 条件]；
        删除语句中不添加条件，则将所有数据都删除

DQL:       查询语句    

selete 字段列表  from 表名列表 while 条件列表 group by 分组字段 having  分组后条件  order by  排序字段  limit  分页限定
        
    基础查询
        查询多个字段  select 字段列表 from 表名； select * from 表名；---查询所有数据
        去除重复记录  select distinct 字段列表 from 表名；
        起别名 as:   as也可以省略；select name as 名字 from stu;
    条件查询（where）
        select 字段列表 from 表名 where 条件列表
        条件 >, <, =, <=, >= ,   <>或 !=, between...and...在某个范围内,  in(...)多选一, is null , is not null , and或&&, or或|| not或！;
        like占位符  模糊查询 通配符： _:代表单个任意字符； %：代表任意个数字符；
            查询姓‘马’:select * from stu where name like'马%'；查询第二个字是‘马’:select * from stu where  name like'_马'；查询名字包含‘马’：select  * from stu where  name like '%马%';
    聚合函数：将一列数据作为一个整体，进行纵向计算
        聚合函数分类 ： count(列名)：统计数量；max(列名)；min(列名)；sum(列名)：求和；avg(列名)：平均值；
        聚合函数语法：select 聚合函数名（列名）from 表；
        null值不参与所有聚合函数运算
    分组查询（group by）
        select 字段列表 from 表名[where 分组前条件限定] group by 分组字段名[ having 分组后条件过滤]；
        查询男女同学各自数学平均分以及各自人数，要求分数低于60不参与分组，分组之后人数大于2
        select sex,avg[math] ，count(*) from stu where math >60 group by sex having count(*) >2;        
        分组后，查询的字段为聚合函数和分组字段，查询其他字段无任何意义
        where 和having 区别：执行时机不一样：where 时分组之前进行限定，不满足where 条件，则不参与分组，而having 时分组之后对结果进行过滤；
                   可判断的条件不一样：where 不能对聚合函数进行判断，having可以；
        执行顺序：where > 聚合函数 > having
        
    排序查询（order by）
        select 字段列表 from 表名 order by 排序字段名1[排序方式1]，排序字段名2[排序方式2]，...;
        排序方式 asc :升序（默认值）desc:降序排序；   select * from stu order by age asc;
        如果有多个排序条件，当前的条件值一样时，才会根据第二条件进行排序
        select * from stu order by math desc,english asc;
    分页查询（limit）
        selsect 字段列表 from 表名 limit 起始索引，查询条目数；
        select * from stu limit 0,3;
        起始索引：从0开始
        计算公式： 起始索引 = （当前页码-1）* 每页显示的条数
        分页查询 limit 是 mysql 数据库的方言，oracle 分页查询使用 rownumber,sql server分页查询使用 top

约束
    概念：作用于表中列上的规则，用于限制加入表中的数据；保证了数据库中数据的正确性，有效性和完整性；
    分类：非空约束：保证列中所有数据不能有null值   not null;   唯一约束：保证数据不相同  unique;    
              主键约束：主键是一行数据的唯一标识，要求非空且唯一   primary key;    检查约束：保证列中的值满足某一条件  check;
              默认约束：保存数据时，未指定值则采用默认值   default；   外键约束：外键用来让两个表的数据之间建立链接，保证数据的一致性和完整性    foreign key;
    mysql 不支持检查约束
    自动增长：auto_increment
    添加约束：创建时添加：create table 表名（列名 数据类型 not null,...）;
        建完表后添加：alter table 表名 modify 字段名 数据类型 not null;
    删除约束：alter table 表名 modify 字段名 数据类型；
    外键约束：外键用来让两个表的数据之间建立链接，保证数据的一致性和完整性
        创建时添加约束：create table 表名（列名 数据类型 ，...[constraint][外键名称]foreign key (外键列名)references 主表 （主表列名））；
        建完表后添加： alter table 表名 add constraint 外键名称 foreign key （外键字段名称）references 主表名称（主表列名称）；
        删除约束：alter table 表名 drop foreign key 外键名称；
数据库设计
        一对多 ：在多的一方建立外键，关联另一方主键
        多对多：建立第三张表，中间表至少包含两个外键，分别关联两方主键
        一对一：多用于表拆分，形成两张表提升查询性能；在任意一方加入外键，关联另一方主键，并设置外键为唯一（unique）;
多表查询
    select * from stu,std where tsu_id = std_id;
    连接查询：内连接：相当于查询A B 交集数据
            隐式内连接：select 字段列表 from 表1，表2 ...where 条件；
            显示内连接：select 字段列表 from 表1 [inner] join 表2 on 条件；
        外连接：左外链接：相当于查询A表所有数据和交集部分数据
                select 字段列表 from 表1 left [outer] join 表2 on 条件；
                     右外链接：相当于查询B表所有数据和交集部分数据
                select 字段列表 from 表1 right [outer] join 表2 on 条件；    
    子查询：查询中嵌套查询，称嵌套查询为子查询
                 子查询根据查询结果不同，作用不同：
            单行单列：作为条件值，使用= ！= < >等进行条件判断
            select 字段列表 from 表 where 字段名 = （子查询）
            多行单列：作为条件值，使用 in 等关键字进行条件判断；
            select 字段列表 from 表 where 字段名 in （子查询）
            多行多列:作为虚拟表
            select 字段列表 from （子查询） where 条件；
事务
    是一种机制，一个操作序列，包含了一组数据库操作命令
    开启事务 start transactton; 或者 begin ; 提交事务：commit; 回滚事务：rollback;
    事务四大特性：原子性、一致性、隔离性和持久性，简称事务的ACID特性；

JDBC
    使用java语言操作关系型数据库的一套API
    public class JDBCDEMO {
        public static void main(String[] args) throws Exception {
            //1.注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2.获取连接
            String url="jdbc:mysql://127.0.0.1:3306/db1";
            String username ="root";
            String password ="1234";
            Connection conn =DriverManager.getConnection(url,username,password);
            //定义SQL
            String sql = "update account set money = 2000 where id = 1";
            //4.获取执行sql的对象 Statement
            Statement stmt = conn.createStatement();
            //5.执行SQL
            int count = stmt.executeUpdate(sql);//受影响的行数
            //6.处理结果
            System.out.println(count);
            //7.释放资源
            stmt.close();
            conn.close();
        }
    }
    DriverManager :（驱动管理类）作用：注册驱动；获取数据库连接
        Class forName("com.mysql.jdbc.Driver");
        static Connection  getConnection(String url ,String user,String password);
        url: 连接路径； jdbc.mysql://ip地址（域名）:端口号/数据库名称？参数键值对1&参数键值对2...
        jdbc:mysql://127.0.0.1:3306/db1(?useSSL="false")
    Connection: (数据库连接对象)作用：获取执行SQL的对象；管理事务；
        普通执行SQL对象：Statement createStatement();
        预编译SQL的执行SQL对象，防止SQL注入: PreparedStatement prepareStatement(sql);
`        执行存储过程的对象：CallableStatement prepareCall(sql)
        事务管理：mysql 事务管理：开启事务 start transactton; 或者 begin ; 提交事务：commit; 回滚事务：rollback;
            jdbc 事务管理：开启事务 setAutoCommit(boolean autoCommit): true为自动提交事务；false:手动提交 ; 提交事务：commit(); 回滚事务：rollback();
        
    Statement：执行SQL语句；
        int executeUpdate(sql): 执行DML，DDL语句；
        返回值：（１）DML语句影响行数（2）DDL语句执行后，执行成功也可能返回0
        ResultSet executeQuery(sql): 执行DQL语句
        返回值：ResultSet 结果集对象
    ResultSet:（结果集对象）作用；
        封装了DQL查询语句的结果：ResultSet stmt executeQuery(sql): 执行语句，返回ResultSet对象
        获取查询结果：boolean next(): (1)将光标从当前位置向前移动一行（2）判断当前行为是否为有效行
            返回值：true:有效行，当前行有数据；false:无效
            xxx getXxx(参数)：获取数据
                xxx：数据类型；如 ：int getint(参数)；String getString(参数)；
                参数：int: 列的编号，从1开始；String: 列的名称
    PreparedStatement: 预编译SQL语句并执行，预防SQL注入问题
            SQl注入：通过操作输入来修改事先定义好的SQl语句，用以达到执行代码对服务器进行攻击的方法
        1.获取PreparedStatement 对象
        //SQL语句中的参数值，使用？占位符替代
        String sql = "select * from user where username = ? and password = ?";
        //通过Connection 对象获取，并传入对应的sql语句
        PreparedStatement pstmt = conn prepareStatement(sql);
        2.设置参数值
        PreparedStatement 对象：selXxx（参数1，参数2）：给？赋值
        Xxx：数据类型：如setint(参数1，参数2)
        参数：参数1：？的位置编号，从1开始；  参数2：？的值
        3.执行sql
        executeUpdate();/executeQuery();不需要再传递sql;
        PreparedStatement: 好处：预编译SQL，性能更高；防止SQL注入，将敏感字符进行转义
        1.PreparedStatement 预编译功能启动：useServerPreStmts=true;
        2.配置MYSQL执行日志：log-output=FILE   general-log=1   general_log_file="D:\mysql.log"  slow-query-log=1  slow_query_log_file="D:\mysql_slow.log"   long_query_time=2
        原理： 1.在获取PreparedStatement对象时，将SQL语句发送给mysql服务器进行检查，编译（这些步骤很耗时）；
            2.执行时就不用再进行这些步骤了，速度很快
            3.如果sql模板一样，则只需要执行一次检查，编译
数据库连接池 ：是个容器，负责分配，管理数据库连接
    标准接口：DateSource
    功能：获取连接 ： Connection getConnection();
    常见数据库连接池：DBCP,C3P0,Druid      
    druid:      driverClassName=com.mysql.jdbc.Driver
        url=jdbc:mysql://localhost:3306/db1?characterEncoding=UTF-8&useSSL=false&useServerPrepStmts=true
        username=root
        password=1234
        # 初始化连接数量
        initialSize=5
        # 最大连接数
        maxActive=10
        # 最大等待时间
        maxWait=3000
Maven :  是专门用于管理和构建JAVA项目的工具
    使用标准的坐标配置来管理各种依赖
    常用命令：compile:编译；claen: 清理；text: 测试；package: 打包；install: 安装
    生命周期：一次构建过程经历多少个事件；对项目构建的生命周期分为3套：clean:清理工作；default:核心工作，如编译，测试，打包，安装等；site:产生报告，发布站点等。
    同一生命周期内，执行后边的命令，前边的所有命令会自动执行
    依赖管理
MyBatis : 优秀的持久层框架，用于简化JDBC开发
    持久层：负责将数据保存到数据库的那一层代码
        javaEE三层架构：表现层，业务层，持久层
    免除了几乎所有的JDBC代码，以及设置参数和获取结果集的工作

    查询user表中所有数据
    1.创建uesr表，添加数据；2.创建模块，导入坐标；3.编写MyBatis核心配置文件--->替换连接信息，解决硬编码问题；
    4.编写SQL映射文件 -->统一管理SQL语句，解决硬编码问题；
    5.编码：1。定义POJO类；2.加载核心配置文件，获取sqlsessionfactory对象；3.获取SqlSession对象，执行SQL语句；4.释放资源；
Mapper 代理
配置文件完成增删改查
    查询所有数据：
        1.编写接口方法：Mapper接口  List<Brand>selectAll();   参数：无； 结果：List<Brand>
        2.编写SQL语句：SQL映射文件；
        ３.执行方法，测试；
        <select id＝＂selectAll()＂ resultType＝＂brand＂＞
            select * from tb_brand;
        ＜/select＞
    查看详情：
        1.编写接口方法：Mapper接口 Brand selectById(int id);   参数：id； 结果：Brand
        2.编写SQL语句：SQL映射文件；
        ３.执行方法，测试；
        ＜select id＝＂selectById()＂resultType＝＂brand＂paeameter Type = "int"＞
            select * from tb_brand; where id = #(id)；
        ＜/select＞
     *参数占位符
        1.#{}:会将其替换为？，防止SQL注入
        2.${}:拼SQL，会存在SQL注入问题
        3.使用时机：
            *参数传递的时候：#{}
            *表名或者列名不固定的情况下：${}会存在SQL注入问题

        *参数类型：parameterType:可以省略
        *SQL语句中特殊字符处理
            1.转义字符
            2.<![CDATA[ 内容]]>

    条件查询
        1.编写接口方法：Mapper接口 Brand selectById(int id);   参数：所有查询条件； 结果：List<Brand>
        2.编写SQL语句：SQL映射文件；
        ３.执行方法，测试；
        <select id＝＂selectByCondition＂resultType＝＂brand＂paeameter Type = "int"＞
            select * from tb_brand where status = #{status} and company_name like #{companyName
            and brand_name like #{brandName}}；
        </select>
        SQL语句设置参数接收方式：    1.散装参数；如果方法中有多个参数，需要使用@Param("SQL参数占位符名称")
                             2.对象参数；对象的属性名称和参数占位符名称一致
                             3.map集合参数:保证SQL参数名和map集合的键的名称对应上
    动态条件查询：SQL语句会随着用户的输入或外部条件的变化而变化，称为动态SQL
        MyBatis 对动态SQL有很强大的支撑：if choose（when, otherwise）trim(where,set)  foreach
            select *from tb_brand  where
                    <if test="status !=null">
                        status = #{status}
                    </if>
                    <if test="companyName !=null and companyName !='' ">
                        and company_name like #{companyName}
                    </if>
            if :用于判断参数是否有值，使用test 属性进行条件判断
            存在问题：第一个条件不需要逻辑运算符
            解决方法：
                     恒等式 1=1  select *from tb_brand  where 1=1 and <if test="status !=null"> status = #{status} </if>
                    <where >替换 where 关键字
                        select *from tb_brand  <where>  <if test="status !=null"> status = #{status} </if></where>
         单条件动态条件查询：从多个条件中选择一个；choose（where，otherwise）：选择，类似于Java中的switch语句
            <choose> --类似于switch ; < when test="status !=null>  -- 类似于 case;   status = #{status}</when><otherwise> 1=1 <otherwise>--类似于default;
    添加： 1.编写接口方法：Mapper接口 void add(Brand brand) ;   参数：除了id之外的所有数据； 结果：void
        2.编写SQL语句：SQL映射文件；
        <insert id ="add"> insert into tb_brand (brand_name,compant_name,ordered,description,status)
        values (#{brandName},#{companyName},#{ordered},#{description},#{status});
        ３.执行方法，测试；
        MyBatis 事务：openSession(): 默认开启事务，进行增删改操作后需要使用sqlSession.commit();手动提交事务
                   openSession(true): 可以设置为自动提交事务（关闭事务）
    返沪添加数据主键 ：<insert useGeneratedKeys = "ture" leyProperty ="id">
    
    修改：修改全部字段：1.编写接口方法：Mapper接口 void update(Brand brand) ;   参数：所有数据； 结果：void
                   2.编写SQL语句：SQL映射文件；
                  ３.执行方法，测试；
        修改动态字段：update tb_brand
        <set>
        <if test="status !=null">
            status = #{status},
        </if>
        <if test="companyName !=null and companyName !='' ">
            company_name like #{companyName},
        </if>
        <if test="brandName !=null and brandName !='' ">
             brand_name like #{brandName},
        </if>
        <if test="description !=null">
            description = #{description},
        </if>
        <if test="ordered !=null ">
            ordered like #{ordered}
        </if>
        </set>

        where id = #{id};
    
    删除：
        删除一个：   1.编写接口方法：Mapper接口 void deleteById(int id) ;   参数：id； 结果：void
                2.编写SQL语句：SQL映射文件；
                ３.执行方法，测试；
        批量删除：1.编写接口方法：Mapper接口 void deleteByIds(@Param("ids")int [] ids) ;   参数：id数组； 结果：void
                2.编写SQL语句：SQL映射文件；
                ３.执行方法，测试；
        delete from tb_brand where id
                in
                <foreach collection = "ids" item = "id" separator = "," open = "(" close =")">
                        #{id}
                </foreach>;
    Mybatis 会将数组参数，封装为一个Map集合。
            * 默认：array = 数组
             * 使用@Param注解改变map集合的默认key的名称
Mabatis参数传递: 单个参数：     1.POJO类型：直接使用，属性名和参数占位符一致
                    2.Map集合：直接使用，键名和参数占位符一致
                    3.Collection：封装为Map集合
                            map.put("arg0"，collection 集合)
                            map.put("collection "，collection 集合)
                    4.List：map.put("arg0"，list集合)
                        map.put("collection "，list 集合)
                        map.put("list "，list集合)
                    5：Array：封装为Map集合
                            map.put("arg0"，数组)
                            map.put("array"，数组)
                    6.其他类型：直接使用
            多个参数：封装为Map集合,可以使用@param注解，替换Map集合中默认的arg键名
                    map.put("arg0"，参数值1)
                    map.put("param1"，参数值1)
                    map.put("param2"，参数值2)
                    map.put("arg1"，参数值2)
                    map.put("arg0"，参数值2)
                    map.put("param1"，参数值2)

    提供了ParamNameResolver类来进行参数封装
    User select(@Param("username")String username, @Param("password")String password);
注解完成增删改查 ：使用注解开发会比配置文件开发更方便
    @Select("select * from tb_user where id = #{id}")
    public User selectById(int id);\
    查询：@Select
    添加：@Insert
    修改：@Update
    删除：@Delect
    注解完成简单功能；配置文件完成复杂功能

HTML ： W3C school
    from : action:指定表单数据提交的URL ；表单项数据想要被提交，则必须指定其name 属性
         method:指定表单提交的方式 ：
            get :默认值  请求参数会拼接再URL后边；请求参数无限制
            post:浏览器会将数据放到http请求消息体中，大小无限制

HTTP 请求数据格式：请求行：请求数据的第一行。其中GET表示请求方式，/表示请求资源路径，HTTP/1.1表示协议版本
            请求头：第二行开始，格式为key：value形式。
            请求体：POST请求的最后一部分，存放请求参数。

    GET请求和POST请求区别：GET请求请求参数在请求行中，没有请求体。POST请求请求参数在请求体中。
                GET请求请求参数大小有限制，POST没有。
    响应数据格式：响应行：响应数据的第一行。其中HTTP/1.1表示协议版本，200表示响应状态码，OK表示状态码描述。
            响应头：第二行开始，格式为KEY：value形式。
            响应体：最后一部分。存放响应数据。

三，导入数据库

//导入mysql数据库
const mysql = require('mysql')

//创建与数据库的链接
const db = mysql.createPool({
	host:'localhost',
	user:'back_system',
	password:'123456',
	database:'back_system'
})

//对外暴露数据库
module.exports = db

//引入数据库
const db = require('../db/index.js')

const sql = 'select * from users where account = ?'
	//第一个参数是执行语句，第二个是前端传来的参数，第三个是一个函数，用于处理结果
	db.query(sql,reginfo.account,(err,results)=>{
		console.log(results)
		if(results.length>0){
			return res.send({
				status:1,
				message:'账号已存在'
			})
		})