MySQL（二）

一、外键

外键是设置当前表中的某一列与别一数据表中的主键列关联。主要目的是控制与外键表中的数据，保持数据一致性，完整性，也就是说：当前表中这一列的数据必须是关联外键列中的某一数据，而且相关联的两个数据列的类型必须相同；当关联外键列某一数据修改或删除时，将触当前表的某一项相应操作。

特点：1、与另一张表的主键相对应

　　　2、外键的存在是为了保证数据的一致性

　　　3、外键的类型与另一张表的主键的类型相同

　　　4、外键中的值在另一张表的主键中必须存在

　　　5、人为创建的关联，起约束作用

　　　6、一张表中的外键可以有多个

	主键	外键	索引
定义：	唯一标识一条记录，不能有重复的，不允许为空	表的外键是另一表的主键, 外键可以有重复的, 可以是空值	该字段没有重复值，但可以有一个空值
作用：	用来保证数据完整性	用来和其他表建立联系用的	是提高查询排序的速度
个数：	主键只能有一个	一个表可以有多个外键	一个表可以有多个惟一索引

创建外键constraint fk_cc foreign key (color_id) references color(nid)
 
命令创建
添加外键：alter table 从表 add constraint 外键名称（形如：FK_从表_主表） foreign key 从表(外键字段) references 主表(主键字段);
 
删除外键：alter table 表名 drop foreign key 外键名称

连表操作之一对多：是指创建的俩张表中，一张表中的数据对应另一张表中的多个数据

连表操作之多对多：是指为了建立俩张表之间的关系，我们可以新建另一张表来对应这俩张表之间多对多之间的关系

连表
    无对应关系则不显示
    select A.num, A.name, B.name
    from A,B
    Where A.nid = B.nid
 
    无对应关系则不显示
    select A.num, A.name, B.name
    from A inner join B
    on A.nid = B.nid
 
    A表所有显示，如果B中无对应关系，则值为null
    select A.num, A.name, B.name
    from A left join B
    on A.nid = B.nid
 
    B表所有显示，如果B中无对应关系，则值为null
    select A.num, A.name, B.name
    from A right join B
    on A.nid = B.nid
 
其中A left join B on xxxx  表示以左边表为主，A表中数据全部显示，B表中的数据如果A表中没有则不显示------------以A为主
其中A right join B on xxxx 表示以右边表为主，B表中数据全部显示，A表中的数据如果A表中没有则不显示------------以B为主
其中A inner join B on xxxx  表示获取AB表中公有的部分，其余不显示---------------------------------------以公共为主

多张表可以连接

select A.num, A.name, B.name  from A
lefe join B  on A.nid = B.nid
lefe join C  on A.nid = C.nid

二、sql注入

所谓SQL注入式攻击，就是攻击者把SQL命令插入到Web表单的输入域或页面请求的查询字符串，欺骗服务器执行恶意的SQL命令。在某些表单中，用户输入的内容直接用来构

（或者影响）动态SQL命令，或作为存储过程的输入参数，这类表单特别容易受到SQL注入式攻击。

1、sql注入的一种方式就是利用字符串的拼接

#这是一种常见的sql注入的方式，利用字符串的拼接
temp = "select name from userinfo  where username='%s'and password =='%s'" %(userinfo,password)
effect_row = cursor.execute(temp)

解决办法：因为pymysql已经为我们做了防止注入，所以我们用他的方法就可以了，其内部就是把特殊字符进行了转译

effect_row = cursor.execute("update hosts set host = '1.1.1.2' where nid > %s", (1,))

三、视图

视图是一个虚拟表（非真实存在），其本质是【根据SQL语句获取动态的数据集，并为其命名】，用户使用时只需使用【名称】即可获取结果集，并可以将其当作表来使用

适用于：很多的sql语句共同对一个结果集进行操作

1、创建视图

CREATE VIEW v1 AS
SELECT * FROM man_to_women
LEFT JOIN man on man_to_women.man_id = man.nid
LEFT JOIN women on man_to_women.man_id = women.nid

2、删除视图

--格式：DROP VIEW 视图名称
DROP VIEW v1

3、修改视图

-- 格式：ALTER VIEW 视图名称 AS SQL语句
 
ALTER VIEW v1 AS
SELET A.nid,
    B. NAME
FROM
    A
LEFT JOIN B ON A.id = B.nid
LEFT JOIN C ON A.id = C.nid
WHERE
    A.id > 2
AND C.nid < 5

4、使用视图

使用视图时，将其当作表进行操作即可，由于视图是虚拟表，所以无法使用其对真实表进行创建、更新和删除操作，仅能做查询用，当我们对真实表进行修改时，视图中的数据会相应的发生变化。

select * from v1

四、触发器

对某个表进行【增/删/改】操作的前后如果希望触发某个特定的行为时，可以使用触发器，触发器用于定制用户对表的行进行【增/删/改】前后的行为。

我们先写一个触发器（这个触发器关联一张或多张表），当我们在对关联的表进行操作的时候，会主动触发这个触发器做出对其他表的操作行为

1、创建基本语法

# 插入前
CREATE TRIGGER tri_before_insert_tb1 BEFORE INSERT ON tb1 FOR EACH ROW
BEGIN
    ...
END
 
# 插入后
CREATE TRIGGER tri_after_insert_tb1 AFTER INSERT ON tb1 FOR EACH ROW
BEGIN
    ...
END
 
# 删除前
CREATE TRIGGER tri_before_delete_tb1 BEFORE DELETE ON tb1 FOR EACH ROW
BEGIN
    ...
END
 
# 删除后
CREATE TRIGGER tri_after_delete_tb1 AFTER DELETE ON tb1 FOR EACH ROW
BEGIN
    ...
END
 
# 更新前
CREATE TRIGGER tri_before_update_tb1 BEFORE UPDATE ON tb1 FOR EACH ROW
BEGIN
    ...
END
 
# 更新后
CREATE TRIGGER tri_after_update_tb1 AFTER UPDATE ON tb1 FOR EACH ROW
BEGIN
    ...
END

动作

delimiter $$
DROP trigger if exists chufaqi_userinfo $$
CREATE trigger chufaqi_userinfo before DELETE on userinfo for each ROW
BEGIN
 insert into man(name) values(old.username);
end $$
delimiter ;

特别的：NEW表示即将插入的数据行，OLD表示即将删除的数据行

old.字段名 表示（BEFORE DELETE,BEFORE UPDATA）删除前后，更新前后的该字段的数据

new.字段名 表示（BEFORE INSERT,BEFROE UPDATA）插入前后，更新前后的该字段的数据

2、删除触发器

DROP TRIGGER 触发器名

3、使用触发器

触发器无法由用户直接调用，而知由于对表的【增/删/改】操作被动引发的

五、存储过程

存储过程可以说是一个记录集吧，它是由一些T-SQL语句组成的代码块，这些T-SQL语句代码像一个方法一样实现一些功能（对单表或多表的增删改查），然后再给这个代码块取一个名字，在用到这个功能的时候调用他就行了

1、创建存储过程

-- 创建简单的存储过程
delimiter $$
create procedure p1()
BEGIN
    select * from t1;
END $$
delimiter ;
 
-- 执行存储过程
call p1()

对于存储过程，可以接收参数，其参数有三类：

• in          仅用于传入参数用
• out        仅用于返回值用
• inout     既可以传入又可以当作返回值

局部变量用一个@标识，全局变量用两个@（常用的全局变量一般都是已经定义好的）；

申明局部变量语法：declare @变量名 数据类型；例如：declare @num int；

-- 创建有参数存储过程
delimiter $$
create procedure p1(
    in i1 int,
    in i2 int,
    inout i3 int,
    out r1 int
)
BEGIN
    DECLARE temp1 int;    -- 表示声明一个变量，声明变量必须提前
    DECLARE temp2 int default 0;
 
    set temp1 = 1;
    set r1 = i1 + i2 + temp1 + temp2;
    set i3 = i3 + 100;
 
end $$
delimiter ;
 
-- 执行存储过程
DECLARE @t1 INT default 3;
DECLARE @t2 INT;
CALL p1 (1, 2 ,@t1, @t2);   -- @xx用于获取返回值
SELECT @t1,@t2;

============储存过程既能返回获取执行select 的结果集 又可以获取out，inout返回值=================

2、删除存储过程

drop procedure proc_name;

3、执行储存过程

-- 无参数
call proc_name()
 
-- 有参数，全in
call proc_name(1,2)
 
-- 有参数，有in，out，inout
DECLARE @t1 INT;
DECLARE @t2 INT default 3;
call proc_name(1,2,@t1,@t2)

pymysql执行存储过程

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import pymysql
 
conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='123', db='t1')
cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)
 
cursor.callproc('p1', args=(1, 22, 3, 4)) #执行存储过程
cursor.fetchall()  #获取执行select的结果集
 
cursor.execute("select @_p1_0,@_p1_1,@_p1_2,@_p1_3")
# 获取执行完存储的参数，其中@_p1_0表示根据索引获取存储过程第一个参数的值
result = cursor.fetchall() # 获取存储过程的返回值
 
conn.commit()
cursor.close()
conn.close()

六、函数

CHAR_LENGTH(str)
返回值为字符串str 的长度，长度的单位为字符
LENGTH(str)
返回值为字符串str的字节长度，长度的单位为字节
 
CONCAT(str1,str2,...)
用于字符串的拼接,如有任何一个参数为NULL ，则返回值为 NULL。
CONCAT_WS(separator,str1,str2,...)
字符串拼接（自定义连接符）,其中separator表示用于连接的连接符
 
CONV(N,from_base,to_base)
用于进制之间的转换、SELECT CONV('a',16,2); 表示将 a 由16进制转换为2进制字符串表示
 
FORMAT(X,D)
将数字X 的格式写为'#,###,###.##',以四舍五入的方式保留小数点后 D 位， 并将结果以字符串的形式返回。若  D 为 0, 则返回结果不带有小数点，或不含小数部分
SELECT FORMAT(12332.1,4); 结果为： '12,332.1000'
 
INSERT(str,pos,len,newstr)
在str的指定位置插入字符串来代替原有字符  insert('alex',2,1,'ddd')---->adddex
特别的：
       如果pos超过原字符串长度，则返回原字符串
       如果len超过原字符串长度，则由新字符串完全替换
 
INSTR(str,substr)
返回字符串 str 中子字符串的第一个出现位置
LEFT(str,len)
返回字符串str 从开始的len位置的子序列字符
 
LOWER(str)
变小写
 
UPPER(str)
变大写
 
LTRIM(str)
返回字符串 str ，其引导空格字符被删除
RTRIM(str)
返回字符串 str ，结尾空格字符被删去
 
SUBSTRING(str,pos,len)
获取字符串子序列
 
LOCATE(substr,str,pos)
获取子序列索引位置
 
SUBSTRING(str,pos) , SUBSTRING(str FROM pos) SUBSTRING(str,pos,len) , SUBSTRING(str FROM pos FOR len)
不带有len 参数的格式从字符串str返回一个子字符串，起始于位置 pos。带有len参数的格式从字符串str返回一个长度同len字符相同的子字符串
,起始于位置 pos。 使用 FROM的格式为标准 SQL 语法。也可能对pos使用一个负值。假若这样，则子字符串的位置起始于字符串结尾的pos 字符,
而不是字符串的开头位置。在以下格式的函数中可以对pos 使用一个负值。
mysql> SELECT SUBSTRING('Quadratically',5);
    -> 'ratically'
 
mysql> SELECT SUBSTRING('foobarbar' FROM 4);
    -> 'barbar'
 
mysql> SELECT SUBSTRING('Quadratically',5,6);
    -> 'ratica'
 
mysql> SELECT SUBSTRING('Sakila', -3);
    -> 'ila'
 
mysql> SELECT SUBSTRING('Sakila', -5, 3);
    -> 'aki'
 
mysql> SELECT SUBSTRING('Sakila' FROM -4 FOR 2);
    -> 'ki'
 
TRIM([{BOTH | LEADING | TRAILING} [remstr] FROM] str) TRIM(remstr FROM] str)
返回字符串 str ， 其中所有remstr 前缀和/或后缀都已被删除。
若分类符BOTH、LEADIN或TRAILING中没有一个是给定的,则假设为BOTH 。 remstr 为可选项，在未指定情况下，可删除空格。
mysql> SELECT TRIM('  bar   ');
    -> 'bar'
 
mysql> SELECT TRIM(LEADING 'x' FROM 'xxxbarxxx');
    -> 'barxxx'
 
mysql> SELECT TRIM(BOTH 'x' FROM 'xxxbarxxx');
    -> 'bar'
 
mysql> SELECT TRIM(TRAILING 'xyz' FROM 'barxxyz');
    -> 'barx'

基本函数

delimiter $$
create function f1(
    i1 int,
    i2 int)
returns int
BEGIN
    declare num int;
    set num = i1 + i2;
    return(num);
END $$
delimiter ;    

自定义函数

删除函数

drop function func_name;

七、事务

事务用于将某些操作的多个SQL作为原子性操作，一旦有某一个出现错误，即可回滚到原来的状态，从而保证数据库数据完整性

delimiter $$
create PROCEDURE p1(       -------创建一个事物
    OUT p_return_code tinyint  ---用于获取返回值
)
BEGIN
  DECLARE exit handler for sqlexception  ---如果执行过程中出现这类错误这执行这里
  BEGIN
    -- ERROR
    set p_return_code = 1; --------把返回值设置成1
    rollback;
  END; 
 
  DECLARE exit handler for sqlwarning ------如果执行过程中出现这类错误这执行这里
  BEGIN
    -- WARNING
    set p_return_code = 2; --------把返回值设置成2
    rollback;
  END; 
 
  START TRANSACTION; -------开始事物
    DELETE from tb1;    ------用于事物的sql语句
    insert into tb2(name)values('seven'); ------用于事物的sql语句
  COMMIT;   ------如果都正确的话则提交，否则执行上面的方法
 
  -- SUCCESS
  set p_return_code = 0;  -------如果执行成功设置返回值为0
 
  END $$
delimiter ;

支持事物的存储过程

执行事务：
DECLARE @i TINYINT;
call p1(@i);
select @i;

八、其他

delimiter $$
CREATE PROCEDURE proc_if ()
BEGIN
 
    declare i int default 0;
    if i = 1 THEN
        SELECT 1;
    ELSEIF i = 2 THEN
        SELECT 2;
    ELSE
        SELECT 7;
    END IF;
 
END $$
delimiter ;

条件语句

delimiter $$
CREATE PROCEDURE proc_while ()
BEGIN
    DECLARE num INT ;
    SET num = 0 ;
    WHILE num < 10 DO
        SELECT
            num ;
        SET num = num + 1 ;
    END WHILE ;
END $$
delimiter ;

while循环

delimiter $$
CREATE PROCEDURE proc_repeat ()
BEGIN
    DECLARE i INT ;
    SET i = 0 ;
    repeat
        select i;
        set i = i + 1;
        until i >= 5
    end repeat;
 
END $$
delimiter ;

repeat循环

delimiter $$
CREATE PROCEDURE proc_loop ()
BEGIN
 
    declare i int default 0;
    loop_label: loop
        select i;
        set i=i+1;
        if i>=5 then
            leave loop_label;
            end if;
    end loop;
 
END $$
delimiter ;

loop

动态执行SQL语句

------用于防止sql注入（在没有用pymysql方法的情况下，第二种防止sql注入）

delimiter $$
DROP PROCEDURE IF EXISTS proc_sql $$
CREATE PROCEDURE proc_sql (
    in strSQL VARCHAR(128),
    in nid  int
)
BEGIN
    set @p1 = nid;
    set @sqll = strSQL;
 
    PREPARE prod FROM @sqll;
    EXECUTE prod USING @p1;
    DEALLOCATE prepare prod; 
 
END $$
delimiter ;

动态执行sql语句

pymysql执行
row = cursor.callporc('proc_sql',('select * from tb2 where nid > ?',6))