备份一下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,和它最初读的版本号不一致,会发生 回滚

你可能感兴趣的:(mysql,数据库,sql)