备份一下mysql笔记

SQLyog：数据库连接软件
    注释：  /* 多行注释*/
               #    单行注释
注意：当执行一条sql语句之后，再次执行一条同样的sql语句（空格等都一样），那么该sql语句不会再次编译
注意：sql语句不区分大小写，字段可以参与运算
注意：字符串尽量以单引号括起来（双引号不通用）
注意：实际开发中不建议使用*号，影响效率（select * from 表名）
注意：mysql支持转义字符，‘\’，  例：字段  like  ‘%\_%’；  //找到含有下划线的数据
注意：所有数据库规定， 数学表达式中有“null”参与运算，结果一定是null（但是分组函数自动忽略null）
注意：表名在数据库当中一般建议以：t_或tbl_开始
注意：在mysql当中，凡是标识符都可以使用“飘号括起来”。不建议使用，并不通用
    飘号：``             //数字1左面的键
注意：数据为空是应写做，列  is  null   
//******数据库的任何一条记录（每行数据），都会有物理地址

注意：在分组时（group by），只有分组的关键字段，才可以出现在select后（oracle需要）

CRUD：增删改查
    Create（增）
    Retrieve（检索）
    Update（修改）
    Delete（删除）

mysql密码修改方式：
    一：
        set password for  用户名@localhost = passw（‘新密码’）；
        例：set password for root@localhost = password（‘123456’）；
    忘记密码时：
        1.关闭正在运行的Mysql服务
        2.打开DOS窗口，转到mysql\bin目录
        3.输入mysql --skip-grant-tables  回车
            --skip-grant-tables  ：启动Mysql服务的时候跳过权限表认证
        4.再次打开一个DOS命令窗口，转到mysql\bin目录下
        5.输入mysql回车，如果成功，将出现Mysql提示符
        6.连接权限数据库：use  mysql；
        7.改密码：update  user  set  password=password（“123”） where  user=“root”；
        8.刷新权限（必须步骤）：flush privileges；
        9.退出 quit。
        10.注销系统，再进入，使用“root（用户名）”和刚刚修改后的密码登录

关于sql、DB、DBMS：
    DB：DataBase（数据库，数据库实际上在硬盘上以文件的形式存在）
    DBMS：DataBase  Management  System（数据库管理系统，常见的有：MYSQL Oracle DB2...）
    SQL：结构化查询语言，是一门标准通用的语言。标准的sql适用于所有的数据库产品
        //sql属于高级语言，在执行的时候，内部也会进行编译，再执行sql
        //（sql语句的编译有DBMS完成）
    DBMS负责执行sql语句，通过执行sql语句来操作DB当中的数据

表的设计三范式（重要）：
    //按照三范式设计的表不会出现“数据冗余”
    第一范式：任何一张表中都应该有“主键”，并且每一个字段原子性不可再分
    第二范式：建立在第一范式的基础之上，所有非主键字段完全依赖主键，不能产生部分依赖
        //多对多，三张表，关系表两个外键
    第三范式：建立在第二范式的基础之上，所有非主键字段直接依赖主键，不能产生传递依赖
        //一对多，两张表，多的表加外键

    //在实际开发中，以满足客户的需求为主，有的时候会拿冗余换执行速度

    一对一设计：两种方案
        主键共享：一张表的一个字段是主键同时也是外键
        外键唯一：一张表中的一个字段是外键同时也是unique（唯一）
关于表（table）：
    table是数据库的基本组成单元，所有的数据都是以表格的形式组织
    一个表包括行和列：
        行：被称为数据/记录（data）
        列：被称为字段（column）
        
    每一个字段包括哪些属性：
        字段名，数据类型，相关的约束
    
    DQL（数据查询语言）：查询语句，凡是select语句都是DQL
    DML（数据操作语言）：insert  delete   update，对表当中的数据进行增删改
    DDL（数据定义语言）：create  drop  alter，对表结构的增删改
    TCL（事务控制语言）：commit提交事务，rollback回滚事务
    DCL（数据控制语言）：grant授权，revoke撤销权限等
告诉目的
涉及到的范围
是否需要条件，条件是什么
【.....】
比较运算符返回的是布尔类型（true或false）
空值！=0（空值不是0，不参加任何运算，Null，空值不占用任意一个字节）
注意：查询的字段可以直接参与运算符操作：+-*/
内置函数：
    ifnull（列名，0）：列名所对应的值如果为null，则替换为0
    concat（【字符串】，列名【....】，字符串）：字符串与列值拼接输出

多表查询：
    内层查询的结果是外层查询的条件
    关键字：
        all：>all大于最大的，         any：>any大于最小的，                    【not】in ：【不】 在
        exists：返回列表中的每一行
        外查询我为where     exists，内查询必须有where语句
合并结果查询：
    //可以将两张不相干的表数据拼接在一起显示
    
    //当两个select查询结果记录条数必须完全一致时，才可以对这两个查询执行合并查询（union）

    select    语句1
    union【all】
    select   语句2
    
        例：select     字段[，字段...]   from  表名
               union
               select     字段[，字段...]   from   表名
        

数据库基本数据类型
1.字符型：  char（数值）         varchar（数值）                  //这里面的char对应java中的String     ，varchar对应StringBuffer/StringBuilder
                 定长字符串        可变长字符串
2.数值型：int           bigint         decimal（p，s）  //bigint对应java中的long
               整数型       长整型
3.浮点型： float      double（7，2）  //7代表有效数字的个数，2代表小数位的个数
                 浮点型              //有效数字：从左边起不为0的数字
4.日期时间类型：date（yyyy-mm-dd）       //对应java.sql.Date类型
              time（hh：mm：ss）
    datetime（yyyy-mm-dd hh：mm：ss）
5.对象类型：  直接存储到数据表中（比较耗费数据库资源）        //对应java中的“Object”
    BLOB：二进制大对象（存储图片、视频等流媒体信息）
    CLOB：字符大对象（存储较大文本，比如，可以存储4G的字符串）

    char（数值）：固定的分配指定空间
    varchar（数值）：根据实际传进来的数据长度，动态的分配空间（只要不超过指定长度）

创建表：（注意：在创建表之前一定要选择对应的数据库，use）
CREATE  TABLE  表名
( <列名>   <数据类型>  [DEFAULT   <默认值>] 
[，…]

注意：基本语法中[]内的代表可有可无；  ，... 代表重复前面的内容。

利用子查询来创建表：
CREATE  TABLE  <表名>
SELECT语句;
(select * from 要复制的表名
注意：select语句的用法

修改表：（注意：结尾注意使用分号）
    更改表名： 
        altear table  旧表名  
             rename  新表名

    添加列：alter table  表名  
        add  【column】 列名   数据类型（）
    修改（数据类型）已有的列：alter   table   表名   
        modify   【column】  列名   新的数据类型（）【新的约束】    
    
    修改列名：alter   table  表名
        change   旧列名   新列名  旧列数据类型    默认值

    删除一列：alter  table  表名
        drop  【column】 列名
    截断表（清空表内数据）：truncate  表名
    default是默认值
清空表内数据：
         delete  from * 表名；
    
insert语句：插入数据   
    insert  into 表名  （字段名[,字段名]）
    values   （值1 [，值]）
    （注意：输入时“字符类型”需要加引号。例：“值”）
    //插入时，如果个别字段未指定值，默认值为null
    //字段顺序可以不固定
更新数据： 
    update 表名
    set  列名=值【，。。。。】       （列）
    【where   <条件>】        （行）

删除数据（可到列）：
    delete   from  表名
    【where   <条件>】  

全部数据拷贝：insert  into 表名  
           select  *  from 被拷贝表名

排序语句：order  by  字段；  //默认是升序
    desc：降序
    asc：默认升序
    意以下两点。
    当SELECT语句中同时包含多个子句，如WHERE、GROUP  BY、HAVING、    ORDER BY，ORDER BY 子句必须是最后一个子句。
    可以使用列的别名、列的位置进行排序。
    
    （可以用列位置号，来代表列）
    //当值相同时，可以再次设置排序，越靠前的字段越能起主导作用
    //by后面的字段（列）可以用数字表示     ， 不建议使用
    select  * from 表名  order  by  字段1，字段2  asc；   //当字段1的数据相同时，按字段2降序（asc）排序

in关键字：是，在（之内的判断，范围）
    
空值的判断：
    is  null 或者 is  not  null
数据查询：
    select  * from  表名 ；（全）       //from后面只能跟表（可以是条select语句，这条查询结果返回一张表）
    select  字段[，字段...]  from  表名；
    select  字段[,字段...]   from   表名  where  字段   =  值      //=可以换成其他运算符

    like：字符串模糊查询通配符：
        % ：0个或任意多个字符   
        _   ：下划线 代表任意一个字符
        格式：列名  like   “字符（可含通配符）”
    查询表：
    select 结果列
    from 表名 
    where 条件     between  在--之间     （ 列  between    ？  and   ？ ）
    group by 分组
    having 分组后的筛选条件
    order by 排序
关于内外连接查询：
    //就是将一个表中的拿出一条数据和另一个表中的所有数据都匹配（表连接无法避免 ）
    //加“条件语句筛选”出现有效记录，但匹配次数并没有发生改变
    要连接的表都要放在from子句，表名之间用逗号（，）隔开。（可设as别名）
    连接条件放在 where子句后面（若多个表有相同列名，可以在列的前面添加表名来区别，例：表名.字段）

    A   join  B  on...   join  C  [join  表名...]   on ...     //多个表进行连接
                    //A和B连接后的结果再和C连接
    

    关于内连接：两张表平等，匹配得上才会查询出来
        相等连接（简单连接）：又叫等值连接，是把两个表中指定列的值相等的行连接起来。
            （1）select   列名【，】   from   表名【，】   where   表名1.列名=表名2.列名（不同表的列）
                //以上语法为sql92老版本语法
            （2）：select   列名【，】     from   表名1 [ inner] join   表名2   on  表名1.列名=表名2.列名  
[where  条件]
                //*****inner关键字可以省略（inner，内部的）
    
        自身连接：通过把一个表定义两个不同别名的方法来完成自身连接
            例：from emp e，emp m（两张表都是emp，但是一张表别名定义为e，另一张表别名定义为m，然后让e和m连接，即为自连接。）

        不等连接（非等值连接）：其连接运算符使用的是非等于符号，暨其他的运算符产生的连接为不等连接。
            例：select 字段[字段...]  from  表名  inner  join   表名   on    between   字段   and  字段

    关于外连接：
        //left和right的位置十分关键，代表着谁是主表
        //在外连接中表有主副之分，当副表中的数据没有和主表中的数据匹配上，副表自动模拟出null与之匹配，*****在匹配中主表的数据不会丢失，而副表迁就与主表
        //数据不可丢失的表作为“主表”
        左外连接：将显示左表中的所有记录和右表中与左表相同列的记录。以下表1 为左表，表2 为右表
             from 表1 left [outer] join 表2 on 表1.列=表2.列
            //outer  可以省略
            
        右外连接：将显示右表中的所有记录和左表中与右表相同列的记录。以下表1 为左表，表2 为右表
             from 表1 right [outer] join 表2 on 表1.列=表2.列
    交叉连接：cross join
        将左右两张表的所有记录做笛卡尔乘积显示

    笛卡尔积现象（笛卡尔乘积现象）：
        如果两张表进行连接查询，并且没有给定任何的条件限制，最终的查询结果是两张表的记录条数乘积
        //就是将一个表中的拿出一条数据和另一个表中的所有数据都匹配
    
    
    
子查询：嵌入在其他sql语句中的一个查询。
    例：select  * from  表名  where  字段 >（select avg（字段） from  表名）；

    select  ...[select]   from [select]   where [select]
    

    子查询还可以继续嵌套其他的子查询，最多可以嵌套255层。
    1．返回单值的子查询
        单值子查询向外层查询只返回一个值。

    2、返回多值的子查询
         在WHERE子句中使用多值子查询时，必须使用多值比较运算符：[NOT]  IN、[NOT]  EXISTS、ANY、ALL，其中ALL、ANY必须与比较运算符结合使用。
    
    1）使用IN操作符的多值子查询
        为子查询返回列表中的任何一个。in操作符会比较子查询返回列表中的每一个值，并且显示任何相等的数据行。

列别名：
    列名 【as】列别名
    select  列名  as  别名【，。。。。】
筛选：  
    select all 列名  from   表名；（保留所有值）
    select  distinct  列名   from  表名；（去掉重复值）
分组：
    //所有分组函数都是对某一组数据进行操作的
    //分组函数一般与group  by联合使用（如果没有group  by，整张表自成一组）
    //*****注意：分组函数不可直接使用在where子句当中
    group by  字段 【，字段】：分组（按某个字段分组）（按某些字段进行分组）
            //多个字段进行分组：类似于  被要求的多个字段进行拼接，然后在进行分组
    having    聚合函数【，聚合函数，可加条件】            （分组后的数据进行再次过滤）
        //注意：having语句只能出现在group by后面，不可以单独出现
    聚合函数（分组函数，多行处理函数）：自动忽略“null ，空”
        count （*）：计算总记录的条数（数据的条数，与字段无关）
        count （字段）： 对一列的值计算个数(这一列的数据条数，忽略了null，记录了该字段中不为null的数据总数量）
        sum  （字段）：求某一列值的总和
        avg  (字段)： 求某一列值的平均值
        max  (字段) ： 求某一列的最大值
        min  (字段)：  求某一列的最小值
    
关于约束：
    在创建表的时候，可以给表的字段添加相应的约束，添加约束的目的是为了保证数据的合法性、完整性、有效性
    常见约束：
        非空约束（not  null）：约束的字段不能为null  （注意：非空约束没有表级约束）
        唯一约束（unique）：约束的字段不能重复，但可以为null
        主键约束（primary  key）：约束的字段既不能为null，也不能重复，一张表的主键约束只能有一个（简称PK）
            //主键相关术语：
                主键字段
                主键值
                主键约束
            //******一张表的主键约束只能有一个

            主键自增：
                create   table  表名（
                    字段   数据类型    primary  key   auto_increment
                ）
                //关键字auto_increment，从1开始递增
        外键约束（foreign  key）：...（简称FK）
            //外键约束的相关术语：
                外键约束：foreign  key
                外键字段：添加有外键约束的字段
                外键值：外键字段中的每一个值
            //有“父子表”之分，子表含有外键约束，父表没有
            外键约束的作用：子表中被外键约束的字段，该字段值 只能在父表被指定字段内的其中一个，不可为其他，就是将子表中的被约束字段和父表的某个字段相关联（引用另一张表的字段）
            //外键值可以为null
            //外键字段引用其他表的某个字段的时候，被引用字段可以不是主键，但要确保该字段有唯一性（有unique约束）
            
            create   table  表名（
                字段    数据类型 ，
                字段    数据类型，
                foreign  key（本表也就是子表字段）   references   父表名（父表字段）
            ）
            
            顺序要求：
                删除数据的时候，先删除子表，再删除父表
                添加数据的时候，先添加父表，在添加子表
                创建表的时候，先添加父表，再添加子表
                删除表的时候，先删除子表，在删除父表

        检查约束（check）：注意oracle数据库有check约束，但是mysql没有，目前mysql不支持该约束
    
        例：（列级约束）
            create  table  表名（
                字段   数据类型    [约束]
                [字段   数据类型   约束]
            ）
        *****（表级约束）多个字段联合约束：多个字段拼接在一起，为一个整体，对这个整体进行“约束”
            例：
                create   table  表名（
                    字段   数据类型，
                    字段   数据类型，
                    unique（字段1，字段2）   //也可以约束单个字段
                ）；

        主键的作用：主键值是每行记录的唯一标识（就像一个人的身份证号码）
        主键的分类：    
            单一主键（常用）：
            复合主键：多个字段联合起来添加一个主键约束（不建议使用）
        根据主键性质划分：
            自然主键（常用）：主键值最好是一个和业务没有任何关系的自然数
            业务主键：主键值和系统的业务挂钩，例如：拿着银行卡的卡号做主键，拿着身份证号码做主键（不推荐使用）            
            

常量与变量：
    常量：
        字符串常量：用单引号或者双引号括起来的字符序列
        数值常量：分为整数常量和小数常量
        日期和时间常量：用特定的字符日期值表示，用单引号表示
        布尔值常量：只有true和false。（0代表true，1代表false）
    变量：
        局部变量：   
            定义与赋值  ：    （1） set   @局部变量名=表达式【，@局部变量=表达式。。。】
                          （2）select    表达式或列名【，表达式】   into     局部变量名【，。。】
                        from  表名    【where  。。。】 
               声明变量：（3）declare    局部变量名【，局部变量名。。】  数据类型  【default   默认值】
                    （注意：无需@声明）
                对变量进行赋值：set   局部变量名=表达式【，局部变量名=表达式】
                
                        
            局部变量的显示：select    @局部变量名【，局部变量名】
        全局变量：是mysql系统提供并赋值的变量，用户不能定义全局变量，只能使用
            为：
            @@back_log：返回mysql主要连接请求的数量
            @@basedir：返回mysql安装基准目录
            @@license：返回服务器的许可类型
            @@port：返回服务器侦听Tcp/ip连接所用的端口
            @@storage_engine：返回存储引擎
            @@version：返回服务器版本号
            
对多变量进行赋值：
    select   列名【，列名..】  into    变量名【，变量名..】
    from   表名
    
字符串函数：str是参数（在mysql中，中文汉字占用3个字节）
    char_length（str）：返回str所包含的字符串个数
    length（str）：返回值为字符串的字节长度
    concat（s1，s2【，s3。。】）：合并字符串（如果有一个参数为null，返回值则为null）

    lower（str）：字母字符全部转换小写
    upper（str）：字母字符全部转换成大写
删除空格：
    ltrim（str）：返回删除前导空格的字符串str
    rtrim（str）：返回删除尾部空格的字符串str
    trim（str）：返回删除两侧空格的字符串str
取子串函数：
    substring（str，start，length）：返回字符串str从start开始长度为length的子串
数学函数：
    abs（x）：返回x的绝对值
    pi（）：返回圆周率π的值
    sqrt（）：返回非负数的二次方根
    mod（m，n）：返回m被n除后的余数
    round（x，y）：把 x 四舍五入到 y 指定的精度返回，如果 y 为负数，则将保留 x 值到小数点左边 y 位
时间和日期函数：
    curdate（）：返回当前系统日期，格式为‘yyyy-mm-dd’
    year（d）：返回日期时间 d 的年
    month（d）：返回日期时间 d 的月
    day（d）：返回日期时间 d 的日
    日期时间
    current_timestamp（）、localtime（）、now（）、sysdate（）：
        均返回当前系统的日期时间，格式为‘yyyy-mm-dd  hh：mm：ss’
        例：select   now（）

    计算两个日期的差：
        timestampdiff（间隔类型，前一个日期，后一个日期）
                         year   
                         month
                ....    
     
系统信息函数：
    user：返回当前登录的用户名
    database：返回当前所使用的数据库
    version：返回mysql的服务器版本号
条件控制函数：
    if（表达式，结果1，结果2）：
        表达式为真，返回结果1。
        表达式为假，返回结果2。
    case（）函数：多重条件
        case  表达式
        when v1 then r1
        when v2  then  r2
        .....
        【else rn】
        end
        如果符合v1，则返回v1后面的r1结果（以此类推）
        如果都不符合，则运行else ，返回rn这个结果

关于  if   语句：
    （1） if  条件（表达式）  then
        sql语句；
               【else     
            sql语句】
        end  if;
    （2）if  条件1（表达式）  then
        sql语句
              elseif      条件2   then
        sql语句；
              else
        sql语句；
              end  if；

        ————————————
case 条件语句：（1） case 
        when  条件  then   语句块
        when  条件  then   语句块
        else     语句块
        end
          （2）  case    表达式
        when  表示式的值1    then   sql语句
        when  表达式的值2    then   sql语句
        .....
        【else    sql语句块】
        end；
关于语句块：（对语句的封装，类似函数）
    begin
    sql语句  |   sql语句块
    end
关于存储函数：
    create function  函数名（【参数名 参数数据类型【，......】】）       #创建一个函数
    returns  函数返回值的数据类型                #确定返回值的数据类型
    begin                        #从这里是，封装函数体的开始
        函数体；                    
        return 语句；
    end                         #结束封装
    调用存储函数：                    
    select 函数名（【参数【，....】】）        
    删除存储函数：        
    drop function 函数名；
关于循环语句：
    loop循环：似递归，有一个出口条件
        （名字）标签：loop
        sql语句块；
        if  条件表达式  then    ##离开条件
        leave  标签（名字）；      ##离开循环
        end if；       ##结束if语句
        end loop；        ##结束loop语句    
    while循环：  
        while  条件表达式  do
        sql语句块；
        end while；
    repeal循环：先循环后判断
        repeat
        sql语句；
        untll  条件表达式
        end repqat；
关于存储过程：（与函数无区别，但无 返回值，字面意思，仅仅用来存储过程，方便再次查询）    
    创建存储过程：
        create  procedure  存储过程名（）
        begin
        过程体；
        end
    调用存储过程：
        call  存储过程名（）
    关于存储过程的参数：
        create  procedure    存储过程名（ in  | out  |  inout  参数1  数据类型 ）
                      输入  输出   输入输出    （参数的区分）
索引：
    创建索引：create   index   索引名    on   表名（列名。。。。）
    查看索引：show   index   from  表名
    删除索引：drop   index   索引名  on   表名
    （注意：索引不可修改）

（注意：char和varchar类型为字符串类型，所以需要加双引号）
关于算术运算符：（与编程同理）
    +
    -
    *
    /
    %    
关于比较运算符：
    <>,!=：不相等
    = ：等于
    >：大于
    <：小于
    >= 
    <=
    between  1值  and  2值:在两值之间（闭区间）      （使用较少，支持值为字符，范围是左闭右开）
        例：where   字段  between  1值  and  2值        //1值必须比2值小
    not  between：不在两值之间
    in ：在集合中
    not in：不在集合中
    <=>：严格比较两个null值是否相等
    like：模糊比较
    is null：为空
    is not  null：不为空
        
关于注释：
    ##：单行注释
    /*  语句  */：多行注释
重置命令“结束标记”：
    平时以分号（；）结尾
    delimiter 符号：用来重新设置结束符号（不要用反斜杠“\”）
    
    转义字符：\反斜杠是转义字符，用来对特殊字符进行转义

ifnull（）空处理函数：
    ifnull（可能为null的数据，可能为null的数据被当做什么处理）
    例：ifnull（sal，0）    //如果sal为null，将会被当做0来处理

关于存储引擎：（只在mysql中存在）
    *****不同的存储引擎会有不同的存储方式（底层存储方式），每一个存储引擎都有自己的优缺点
    //建表的时候可以指定存储引擎，也可以指定字符集
    mysql默认使用的存储引擎是InnoDB方式
    默认采用的字符集是UTF8
    常用存储引擎：
        MyISAM（常用）：使用三个文件表示每个表
            表名.frm：存储表结构的文件（格式文件）
            表名.MYD：存储表中数据的文件（数据文件）
            表名.MYI：存储表中索引的文件（索引文件）
            优点：可被压缩，节省存储空间，可以转换为只读表，提高检索效率
            缺点：不支持事务
        **********************************************************************
        InnoDB（mysql默认存储引擎，常用）：
            表名.frm：存储表的结构            
            //数据存储在tablespace这样的表空间中（逻辑概念），无法压缩，无法转换制度，但在mysql数据库崩溃后提供自动恢复机制
            优点：支持事务、行级锁、外键等，这种存储引擎数据的安全得到保障，支持级联删除，级联更新
        **********************************************************************
        MEMORY（原称“HEPA”）：
    
            优点：查询速度最快
            缺点：不支持事务，数据容易丢失。因为所有数据和索引都是存储在内存中    
    
关于级联删除和级联更新：
    例如：外键父子表，父表和子表之间有联系，父表“被关联字段”更新，子表相关数据更新，父表删除，子表相关联的数据也会删除

关于事务：（像是将多个DML语句整合在一起，作为一个整体，进行执行，是一个共同体，同时成功，同时失败）
    一个事务是一个完整的业务逻辑单元，不可再分
    //事务的存在是为了保证数据的完整性，安全性
    例：银行账户转账，从a账户向b账户转账10000，需要执行两条update语句：
        update  t_act  set balance = balance-10000  where  actno='act-001';
        update  t_act  set balance = balance+10000  where actno='act-002';
        //以上两条DML（对表数据的操作）语句必须同时成功
        //而要想保证以上两条DML语句同时成功或者同时失败，就需要使用数据库的“事务机制”
    //*****和事务相关的语句只有“DML”语句（对表数据的操作）
    

    事务的四大特性：ACID
        A：原子性：事务是最小的工作单元，不可再分
        C：一致性：事务必须保证多条DML语句同时成功或者同时失败
        I：隔离性：事务A与事务B之间具有隔离性
        D：持久性：最终数据必须持久化到硬盘文件，事务才算成功的结束

    关于事务之间的隔离性：
        事务隔离性存在隔离级别，理论上“隔离级别”包括4个：
            第一级别：读未提交（read  uncommitted）
                //对方事务还没有提交，我们当前事务可以读取到对方未提交的数据
                //读未提交存在脏读（Dirty  Read）现象：表示读到了脏的数据
            第二级别：读已提交（read  committed）
                //解决了脏读现象
                //对方事务提交之后的数据我方可以读取到
                //读已提交存在的问题是：不可重复性
            第三级别：可重复读（repeatable  read）
                //这种隔离级别解决了：不可重复读问题
                //这种隔离级别存在的问题是：读到的数据是幻象
                //读到的其实是备份数据
            第四级别：序列化读/串行化读
                解决了所有问题
                效率低。需要事务排队
            oracle数据库默认的隔离级别是：读已提交
            mysql数据库默认的隔离级别是：可重复读 
        //*****mysql事务默认情况下是自动提交的。
            自动提交：只要执行任意一条DML语句则提交一次
            //*****关闭自动提交（开启事务）   ：   start  transaction；
            
        commit  ：  提交事务
        rollback：回滚到上一次的提交点（也会提交事务）
        set  global  transaction   isolation   level  read  uncommitted；//设置全局的事务隔离级别   为读未提交
        select  @@global.tx _isolation   //查看事务的全局隔离级别
        //开启事务  会创建一个缓冲区，而DML语句会在缓存区模拟语句成功后的数据结果，但不会修改硬盘文件并保存，可以使用回滚，回到上一个提交点
        //只有提交事务（commit），才会修改硬盘文件的内容

关于索引：
    索引相当于一本书的目录，通过目录可以快速的找到对应的资源
    在数据库方面，查询一张表的时候有两种检索方式：
        第一种方式：全表扫描
        第二种方式：根据索引检索（效率很高）
    //索引最根本的原理是缩小了扫描的范围，提高了检索效率
    //索引不能随意添加，表中的数据经常被修改不适合添加索引，数据一旦修改，索引需要重新排序
    //添加索引是给某一个字段或某些字段添加索引
    /索引会自动排序
    //*****注意：主键和具有unique约束的字段自动会添加索引（主键查询效率较高）
    *****给字段添加索引的建议条件：
        1.数据量庞大
        2.该字段很少的DML操作（因为字段进行修改操作，索引也需要维护）
        3.该字段经常出现在where子句中（经常根据哪个字段查询）

    //索引底层采用的数据结构是：B+Tree
    
    索引的分类：
        单一索引：给单个字段添加索引
        复合索引：给多个字段联合起来添加1个索引
        主键索引：主键上会自动添加索引
        唯一索引：有unique约束的字段上会自动添加索引
        ...
    //注意：模糊查询，第一个通配符使用“%”，这个时候索引失效

关于视图（view）：
    站在不同的角度去看数据。（同一张表的数据，通过不同的角度去看待）
    create  view  视图名  as   DQL语句（查询语句）
    drop   view  视图名
    //只有DQL语句才能以视图对象的方式创建出来
    //*****对视图的增删改查（CRUD操作），会影响原表数据
    视图的作用：
        视图可以隐藏表的实现细节。保密级别较高的系统，数据库只对外提供相关的视图，java程序员只对视图对象进行CRUD。

DBA命令：
    将数据库的当中的数据导出：sql脚本
        在windows的dos命令窗口中执行：
            mysqldump  库名  emp>绝对路径\表名.sql   -uroot  -p密码
            mysqldump -u 用户名 -p 数据库名 > 导出的文件名
            //> ： 输出
            //emp：？？
    导入数据：
        create  database   库名  //先创建数据库
        use   库名    //使用库
        source    sql脚本绝对路径
explain    sql语句；  查看sql语句的执行计划
default current _timestamp  默认当前时间戳
char（）   定长字符串      可规定
varchar（）   变长字符串    可变通
not   非
exists    存在
show   显示
warnings  警告信息
use   使用
tables    表
between  在--之间
and  与
or   或
not  非
desc  降序排序
in（值[值...]）  等同于or
    例：select * from 表名 where 字段 in  (值,值[值...]) ;//in后面不是区间，是具体的值
not  in（值[值...]）：不在这个区间内

like：字符串模糊查询通配符：
        % ：0个或任意多个字符   
        _   ：下划线 代表任意一个字符
        格式：字段  like   “字符（可含通配符）”

distinct   不同的     //去除重复记录
    例：select  distinct  字段[字段...]  from  表名
    //注意：distinct只能出现在所有字段的最前方，表示后面的字段会联合起来，由distinct去重
limit  行数
    limit  index，num
    limit   //限制，分页关键字
    //index  查询数据的起始索引（起始位置），从0开始，参数可省略，默认起始位置为0
    //num  每页显示的数据条数
    //*****limit是sql语句最后的一个环节

    *****分页通用公式：
        第pageNo页：（pageNo-1）*  pageSize，pageSize
        //是“（页数-1）   *    一页显示数据量”

show  engines  \G   ：查看mysql当前支持的存储引擎
show  procedure status：查看当前数据库下所有的存储过程
show  create  procedure  标签名：查看指定的存储过程（未测试，应该可行）
show  function  status：查看当前数据库下所有的函数
show  create  function  函数名：查看指定函数（可行）

int（n）：n代表的是这个字段的存储的数据的宽度为n位数
select * from 表名：查询表中所有数据
select  从数据库中提取数据
update  更新数据库中的数据
delete   从数据库中删除数据
insert into 向数据库插入新数据
create database  创建新数据库
create table  创建新表
later database  修改数据库
later table  改变数据库表
drop table  删除表
drop  table  if  exists  表名        //该表如果存在则删除该表
create index  创建索引
drop  index  删除索引

show   databases；   显示所有数据库
status；     显示数据库状态
create  database   数据库名字；    创建数据库
create  database   if  not  exists  数据库名字；  如果不存在创建该数据库
show   create  dataease    数据库名字；          查看建库语句
show   create  table   表名；      查看建表语句
show   warnings； 显示警告信息
drop   database  数据库名；  删除数据库
select  字段【，。。。】 from  表名;   从表中选取数据
use  数据库名；    使用数据库
show  tables；    使用数据库后，显示该数据库的所有表
select  database（）；   查看当前使用的数据库
select  version();     查看当前mysql版本号
exit  退出MySQL命令窗口
source   sql文件路径； 导入sql文件的数据（文件以sql结尾，叫做“sql脚本”）
show  tables  from  数据库；  查询其他数据库的表
字段 as  别名       //为字段起别名，as关键字可省略 
desc   表名； 查询表中的数据结构
where  字段 is null；  //该字段为null的数据
where  字段 is not null； //该字段不为null的数据
select * from 表名 where 字段='值' and 字段='值' or 字段='值' and 字段='值';  //注意：and的优先级比or要高，当运算符优先级不确定的时候加小括号
    例：select * from 表名 where     （ 字段='值' or  字段='值'） and 字段='值'

select  表名1.*，表名2.*  from  ....   //多表连接查询表1,2的所有字段

select * from 表名;
**********************************************************一个完整的DQL语句顺序****************
SELECT [ALL|DISTINCT] <目标列表达式>[,<目标列表达式>]…            5
  from <表名或视图名>[,<表名或视图名>]…              1
  [where <条件表达式>]                      2
  [group  by <列名> ]                      3     //分组函数只有在group  by函数执行之后才可以使用
  [having <条件表达式>]]                      4
  [order  by <列名> [ASC|DESC]…]                  6
  [limit]   ...                          7

***************************************************************************************************
创建表：（注意：在创建表之前一定要选择对应的数据库，use）
create  table   表名(
 <字段名>    <数据类型>    [default   <默认值>] 
[，…]）；
***************************************************************************************************
insert  into 表名  （字段名[,字段名]）
values   （值1 [，值]）[，（值...）]
    （注意：输入时“字符类型”需要加引号。例：“值”）
    //插入时，如果个别字段未指定值，默认值为null
    //字段顺序可以不固定
    //字段名可以省略，如果省略，则values必须按字段顺序输入值
        例：insert   into  表名   values（按字段的顺序输入“值”）
    //插入多行数据
        insert   into  表名（字段名【，字段名...】）  values   （值...），（值...）   
***************************************************************************************************
利用子查询来创建表：  查询结果当做表创建出来
    create  table  <表名>   as  select语句;
        //(select * from 要复制的表名）
        注意：as可以省略
****************************************************************************************************
将一张表的数据插入到另一张表中（前提是两张表的字段数量相同）
insert  into  表名1    select  * from  表名2
****************************************************************************************************
更新的数据： 
    update 表名
    set  字段名=值【，字段名=值...】      
    【where   <条件>】
    //注意：如果没有条件整张表全部更新    
****************************************************************************************************
删除数据（可到列）：
    delete   from  表名
    【where   <条件>】  
    //注意：如果不加条件数据全部删除
    //如果数据量庞大，delete语句效率较慢，删除时不会释放物理地址，可以利用回滚事务回滚，
    当确定表内的数据不在需要后，可使用truncate语句
        truncate   table  表名；   //截断表（清空表内数据）
                //删除后不可使用回滚事务回滚，数据永久丢失
**************************************************************************************************
修改表：（注意：结尾注意使用分号）
    //开发使用较少，可直接使用工具进行修改
    更改表名： 
        altear table  旧表名  
             rename  新表名

    添加字段：alter table  表名  
        add  【column】 字段名   数据类型（）
    修改（数据类型）已有的字段：alter   table   表名   
        modify   【column】 字段名   新的数据类型（）【新的约束】    
    
    修改字段：alter   table  表名
        change   旧列名   新字段名  旧列数据类型    默认值

    删除字段：alter  table  表名
        drop  【column】 字段名
    default是默认值
**************************************************************************************************
关于索引：
    创建索引对象：create   index   索引名    on   表名（字段名[字段名...]）
        //给指定字段添加索引
    查看索引对象：show   index   from  表名
    删除索引对象：drop   index   索引名  on   表名
    （注意：索引不可修改）
**************************************************************************************************
关于行级锁（悲观锁）：关键字 for  update
    //将查询出来的数据“锁住”，使其无法进行修改，在原表中锁住（其他线程或事务无法进行修改）
    //*******事务必须排队执行，数据锁住了，不允许并发
    例：select ename,job,sal  from  emp  where job=“manager” for  update 
    //在select查询语句后面加 for update 关键字，就可以添加行级锁（悲观锁）

关于乐观锁：
    //多线程并发，都可以对这条记录进行修改  
    //*******支持并发，事务也不需要排队，只不过需要一个版本号
    
    事务1-->读取到版本号1.1
    事务2-->读取到版本号1.1
    其中事务1先修改了，修改之后看了版本号是1.1，于是提交修改的数据，将版本号修改为1.2
    其中事务2后修改的，修改之后准备提交时，发现版本号是1.2，和它最初读的版本号不一致，会发生 回滚