• 视图&&事务&&索引&&触发器&&流程控制


    视图、事务、索引,触发器,流程控制。

    视图:view

    视图与真实表共享数据,视图和真实表的数据会相互映射,

    视图的表结构只要存在真实表的数据只要存在,视图就可以使用。

    数据依赖:单表emp

    1)视图是存在内存中的临时表
    2)视图的创建依赖select语句,所有就是select语句操作的结果形参的表
    3)视图支持对数据的增删查改 ?
    4)视图不允许对视图表的字段做修改
    5)视图不仅支持创建,也支持更新与删除

    语法:创建视图
    
    mysql>: create view 视图名[(别名们)] as select 语句;
    eg>: create view v1 as select dep, max(salary) from emp group by dep;
    
    # 创建或替换视图
    mysql>: create or replace 视图名[(别名们)] as select 语句;
    mysql>: alter 视图名[(别名们)] as select 语句;
    eg>: create or replace view v1(dep_name, max_salary) as select dep, max(salary) from emp group by dep;
    eg>: alter view v1(name, salary) as select dep, max(salary) from emp group by dep;
    
    # 删除视图
    mysql>: drop view 视图名
    eg>: drop view v1;
    
    # 视图可以作为正常表完成连表查询
    select name, dep_name, salary 
    from emp join v1 
    on emp.dep=v1.dep_name and emp.salary=v1.max_salary;
    

    视图的增删改

    # 前提:视图的增删改操作可以直接映射给真实表(本质就是对真实表进行操作)
    
    # 视图可以完成增删改,增删改本质是直接对创建视图的真实表进行操作
    create or replace view v2 as select id,name,age,salary from emp;
    update v2 set salary=salary+1 where id=1;
    delete from v2 where id=1;
    
    create or replace view v3 as select * from emp;
    insert into v3 values(1, 'yangsir', '男', 66, 1.11, '上海', '那噶的', '教职部');
    
    # 总结:操作视图,会影响真实表,反之也会影响
    update emp set salary=salary+1 where id=1;
    

    事务

    满足事物的四大特性就是事物。mysql语句自动启动事物,每一句都是事物的执行过程。

    事务的四大特性
    1.原子性:事务是一组不可分割的单位,要么同时成功,要么同时不成功
    2.一致性:事物前后的数据完整性应该保持一致(数据库的完整性:如果数据库在某一时间点下,所有的数据都符合所有的约束,则称数据库为完整性的状态)
    3.隔离性:事物的隔离性是指多个用户并发访问数据时,一个用户的事物不能被其它用户的事务所干扰,多个并发事务之间数据要相互隔离
    4.持久性:持久性是指一个事物一旦被提交,它对数据的改变就是永久性的,接下来即使数据库发生故障也不应该对其有任何影响

    # 事务:通常一些业务需要多条sql参与,参与的sql会形参一个执行整体,该整体我们就称之为 事务
    # 简而言之:事务 - 就是保护多条执行的sql语句
    # 比如:转账就是一个事务:从一个用户将资金转出,再将资金转入到另一个用户
    
    事务的使用:
    start transaction; --开启事物,在这条语句之后的sql将处在同一事务,并不会立即修改数据库
    commit;--提交事务,让这个事物中的sql立即执行数据的操作,
    rollback;--回滚事务,取消这个事物,这个事物不会对数据库中的数据产生任何影响
    

    事务的用户隔离级别:
    数据库使用者可以控制数据库工作在哪个级别下,就可与防止不同的隔离性问题
    read uncommitted --不做任何隔离,可能脏读,幻读
    read committed --可以防止脏读,不能防止不可重复读,和幻读,
    Repeatable read --可以防止脏读,不可重复读,不能防止幻读
    Serializable --数据库运行在串行化实现,所有问题都没有,就是性能低

    修改隔离级别:
    select @@tx_isolation;--查询当前级别 
    set[session|global] transaction isolation level ....;修改级别
    实例:
    set global transaction isolation level Repeatable read;
    注:修改后重新连接服务器生效
    
    
    
    
    
    

    what:事务是逻辑上的一组操作,要么都成功,要么都失败
    why:很多时候一个数据操作,不是一个sql语句就完成的,可能有很多个sql语句,如果部分sql执行成功而部分sql执行失败将导致数据错乱
    eg:转账 => 转入转出均成功,才能认为操作成功

    # mysql中事务的执行
    create table bank(
    	id int,
        name varchar(16),
        money decimal(65, 2)
    );
    insert into bank values(1, 'Tom', 10), (2, "Bob", 10);
    
    # 假设出现以下执行情况
    
    # 没有事务支持情况下,Tom的钱就丢了
    update bank set money=money-1 where name='Tom';
    update bank set money=money+1 where name='ruakei';
    
    
    
    
    # 将两条sql看做事务处理
    # 开启事务
    begin;
    update bank set money=money-1 where name='Tom';
    update bank set money=money+1 where name='ruakei';
    # 确认无误,提交事务
    commit;
    # 确认有误,回滚
    rollback;
    

    索引

    索引就是 键 - key

    1)键 是添加给数据库表的 字段 的
    2)给表创建 键 后,该表不仅会形参 表结构、表数据,还有 键的B+结构图
    3)键的结构图是需要维护的,在数据完成增、删、改操作时,只要影响到有键的字段,结构图都要维护一次
    所以创建键后一定会降低 增、删、改 的效率
    4)键可以极大的加快查询速度(开发需求中,几乎业务都和查有关系)
    5)建立键的方式:主键、外键、唯一键、index

    import pymysql
    from pymysql.cursors import DictCursor
    conn = pymysql.connect(user='root', passwd='root', db='oldboy')
    cursor = conn.cursor(DictCursor)
    
    # 创建两张表
    # sql1 = """create table a1(
    #     id int primary key auto_increment,
    #     x int,
    #     y int
    # )"""
    # cursor.execute(sql1)
    # sql2 = """create table a2(
    #     id int primary key auto_increment,
    #     x int,
    #     y int,
    #     index(x)###############索引,对x的索引,增加索引,提高查询率。
    # )"""
    # cursor.execute(sql2)
    
    # 每个表插入5000条数据
    # import random
    # for i in range(1, 5001):
    #     x = i
    #     y = random.randint(1, 5000)
    #     cursor.execute('insert into a1(x, y) values(%s, %s)', (x, y))
    #     cursor.execute('insert into a2(x, y) values(%s, %s)', (x, y))
    #
    # conn.commit()
    
    import time
    # a1的x、a1的id、a2的x
    b_time = time.time()
    sql = 'select * from a1 where id=4975'
    cursor.execute(sql)
    e_time = time.time()
    print(e_time - b_time)
    
    b_time = time.time()
    sql = 'select * from a1 where x=4975'
    cursor.execute(sql)
    e_time = time.time()
    print(e_time - b_time)
    
    b_time = time.time()
    sql = 'select * from a2 where x=4975'
    cursor.execute(sql)
    e_time = time.time()
    print(e_time - b_time)
    
    
    

    触发器

    what:在表发生数据更新时,会自动触发的功能称之为触发器
    why:当一个表在发生数据更新时,需要去完成一些操作,可以为具体数据更新的方式添加触发器

    '''
    
    
    语法:
    delimiter //
    create trigger 触发器名 before|after insert|update|delete on 表名 for each row
    begin 
        需要触发执行的sql代码们
    end //
    delimiter ;
    
    # 触发器名: t1_before_insert_tri
    
    注:delimiter是用来修改sql的语句结束标识符
    
    删除触发器:drop trigger 触发器名;
    '''
    
    # cmd表
    create table cmd (
        id int primary key auto_increment,
        user char(32),
        priv char(10),
        cmd char (64),
        sub_time datetime, # 提交时间
        success enum ('yes', 'no') # 0代表执行失败
    );
    # 错误日志表
    create table errlog (
        id int primary key auto_increment,
        err_cmd char(64),
        err_time datetime
    );
    # 创建触发器
    delimiter //
    create trigger trigger1 after insert on cmd for each row
    begin
    # new就是cmd当前插入的那条记录(对象)
    if new.success = "no" then
    	insert into errlog values(null, new.cmd, new.sub_time);
    end if;
    end //
    delimiter ;
    
    # 往表cmd中插入记录,触发触发器,根据IF的条件决定是否插入错误日志
    insert into cmd(user, priv, cmd, sub_time, success) values
        ('egon', '0765', 'ls -l /etc', now(), 'yes'),
        ('jerry', '0852', 'cat /etc/passwd', now(), 'no'),
        ('kevin', '0867', 'useradd xxx', now(), 'no'),
        ('owen', '0912', 'ps aux', now(), 'yes');
    # 查看cmd数据信息
    select * from cmd;
    # 查看错误日志表中的记录是否有自动插入
    select * from errlog;
    

    存储过程

    what:用于完成指定功能的sql语句块,类似于Python中的函数
    why:将能指定功能的sql语句块建立成存储过程,不仅将sql语句逻辑化了,更是功能化了,那我们要完成相同的事,只需要重复使用建立的存储过程,不就需要再重复书写sql语句了

    总结: 存储过程可以让sql语句具有 复用性, 从而提高开发效率

    变量的使用:
    1.赋值变量:set @变量名 = 变量值
    2.使用变量:@变量名 | select @变量名
    3.删除变量:set @变量名 = null

    三种开发方式:

    1. 业务逻辑 + 存储过程:高执行与开发效率,低耦合 | 不易移植,人员成本高
    2. 业务逻辑 + 原生sql:人员成本低 | 开发难度大
    3. 业务逻辑 + ORM:高开发效率,对象化操作数据库,可移植 | 性能消耗加大,多表联查、复杂条件会复制化ORM
    语法:
    delimiter //
    create procedure 存储过程名(
    	输入输出类型1 参数名1 参数类型1(宽度), 
    	... ,
    	输入输出类型n 参数名n 参数类型n(宽度)
    )
    begin
    sql语句块
    end //
    delimiter ;
    注:
    1.输入输出类型:in | out | inout
    2.call 存储过程名(实参们)来调用存储过程
    
    案例:
    set @res = null; # 定义空值变量, 用来接收存储过程的执行结果
    delimiter //
    create procedure user_info(in b int, in l int, out res char(20))
    begin
    select * from emp limit b, l;
    set res = 'success';
    end //
    delimiter ;
    call user_info(2, 3, @res); # 调用存储过程, 传入相应的实参
    select @res; # 查看存储过程的执行结果
    
    
    存储过程的操作:
    1.查看
    select routine_name, routine_type from information_schema.routines where routine_schema='数据库名';
    
    eg: select routine_name, routine_type from information_schema.routines where routine_schema='db2';
    
    2.删除
    drop procedure [if exists] 数据库名.存储过程名
    '''
    
    
    delimiter //
    create procedure send_money( out p_return_code char(20) )
    begin 
    	# 异常处理
        declare exit handler for sqlexception 
        begin 
            # error 
            set p_return_code = '错误异常'; 
            rollback; 
        end; 
    	# exit 也可以换成continue 表示发送异常时继续执行
        declare exit handler for sqlwarning 
        begin 
            # warning 
            set p_return_code = '警告异常'; 
            rollback; 
        end; 
    
        start transaction;
    	update account set money = money - 1000 where id = 1;
    	update account set money = moneys + 1000 where id = 2; # moneys字段导致异常
        commit; 
    
        # success 
        set p_return_code = '转账成功'; # 代表执行成功
    end //
    delimiter ;
    
    # 在mysql中调用存储过程
    set @res=null;
    call send_money(@res);
    select @res;
    
    

    流程控制

    • if语句的使用
    第一种 if:
    """
    if 条件 then
    语句;
    end if;
    """
    第二种 if elseif
    """
    if 条件  then
    语句1;
    elseif 条件 then
    语句2;
    else 语句3;
    end if;
    """
    
    

    案例:编写过程 实现 输入一个整数type 范围 1 - 2 输出 type=1 or type=2 or type=other;

    delimiter //
    create procedure showType(in type int,out result char(20))
    begin
    if type = 1 then 
    set result = "type = 1";
    elseif type = 2 then 
    set result = "type = 2";
    else 
    set result = "type = other";
    end if;
    end //
    delimiter ;
    
    set @res=null;
    call showType(100, @res);
    select @res;
    
    
    • CASE 语句

    大体意思与Swtich一样的 你给我一个值 我对它进行选择 然后执行匹配上的语句
    语法:

    create procedure caseTest(in type int)
    begin
    CASE type 
    when 1  then select "type = 1";
    when 2  then select "type = 2";
    else select "type = other";
    end case;
    end
    
    
    • 定义变量

    declare 变量名 类型 default 值;
    例如: declare i int default 0;

    • WHILE循环
    循环输出10次hello mysql
    create procedure showHello()
    begin 
    declare i int default 0;
    while  i < 10 do
    select "hello mysql";
    set i  = i + 1;
    end while;
    end
    
    
    • LOOP循环的

    没有条件 需要自己定义结束语句
    语法:

    输出十次hello mysql;
    create procedure showloop()
    begin 
    declare i int default 0;
    aloop: LOOP
    select "hello loop";
    set i = i + 1;
    if i > 9 then leave aloop;
    end if;
    end LOOP aloop;
    end
    
    
    • REPEAT循环
    #类似do while
    #输出10次hello repeat
    create procedure showRepeat()
    begin
    declare i int default 0;
    repeat
    select "hello repeat";
    set i = i + 1;
    until i > 9
    end repeat;
    end
    
    #输出0-100之间的奇数
    create procedure showjishu()
    begin
    declare i int default 0;
    aloop: loop
    set i = i + 1;
    if i >= 101 then leave aloop; end if;
    if i % 2 = 0 then iterate aloop; end if;
    select i;
    end loop aloop;
    end
    
    
  • 相关阅读:
    poj 2243 bfs 利用 结构体中的step成员保存步数 ,STL的队列
    poj 1915 双向 BFS 利用数组 a[x][y] = a[cp.x][cp.y] + 1; b[x][y] = b[cp.x][cp.y] + 1;保留步数
    poj 1915 BFS 利用 pre 计算步数------------------路径
    hdu 1242
    poj 2243
    rwkj 1502
    png-CRC32校验
    uva-331-枚举-交换的方案数
    uva-301-枚举-组合
    关于docker
  • 原文地址:https://www.cnblogs.com/SkyOceanchen/p/11743182.html
Copyright © 2020-2023  润新知