事实上，方式2 就是方式1：

self.rowcount = sum(self.execute(query, arg) for arg in args)

总结： 一般的执行流程：

• 建立连接
• 获取游标
• 执行SQL
• 提交任务
• 释放资源

SQL 注入攻击：

找出用户id 为 6 的用户信息的SQL 语句如下：

SELECT * FROM students WHERE id= 6

本以为如上的查询语句，但是实施上， SELECT * FROM `t1` WHERE age=30 or 1 ; 也就是通过字符拼接，还是可以获取所有的表中数据。

现在，要求可以找出某个id对应用户信息，代码如下：

1 userid = 5
2 sql = "SELECT * FROM stedents WHERE id={}".format(userid)

userid 可以变，例如从客户端 request请求 中获取，直接拼接到查询字符串中。

可是，如果userid = ‘5 or 1=1’   呢？

运行的结果 竟然是返回了所有的数据。

（这就是利用 拼接 ，包括引号等 ，拼接出 类似 SELECT * FROM `t1` WHERE age=30 or 1）

SQL 注入攻击：

猜测 后台数据库的查询语句使用拼接字符串的方式，从而经过设计为服务端传参，令其拼接出特殊字符串的SQL 语句，返回攻击者想要的结果。

永远不要相信客户端传来的数据是规范的 ，安全的。！！！

如何解决：

1、参数化查询 ，可以有效防止注入攻击，并提高查询的效率。

2、同时不要报 详细的异常给客户端。

Cursor.execute（query, args= None):

args, 必须是元组，列表或字典， 如果查询字符串使用 %（name）s, 就必须使用字典。

 1 import pymysql
 2 from pymysql.cursors import  DictCursor
 4 conn = pymysql.connect('192.168.112.111', 'root','123456', 'test')
 5 cursor = conn.cursor(DictCursor)
 7 userid = '5 or 1=1'
 8 sql = 'SELECT * FROM t1 WHERE id=%s'
 9 cursor.execut(sql,(userid,)) # 参数化查询
10 print(cursor.fetchall())
12 sql = 'SELECT * FROM t1 WHERE `name` like %(name)s and age > %(age)s'
13 cursor.execute(sql, {'name':'tom%', 'age':25}) # 参数化查询
15 if cursor:
16     cursor.close()
17 if conn:
18     conn.close()

结果 ：没有吧所有的数据显示出来。只显示要查询的行

[ { 'age':20, 'id' : 5, 'name':'tom0'}]

参数化查询为什么会提高效率：

原因是 ---SQL 语句缓存，

数据库服务器一般会对SQL 语句编译和缓存，编译只对SQL 语句部分，所以参数中就算有SQL 指令也不会被执行。

编译过程，需要 词法分析，语义分析，生成AST（语法抽象树，倒转的），优化，生成执行计划等过程 ，比较耗费资源。

服务端 会先查找是否对同一条查询语句进行了缓存，如果缓存未失效，则不需要再次编译，从而降低了编译的成本，降低了内存消耗

可以认为SQL 语句字符串就是一个KEY， 如果使用拼接方案，每次发送过去的SQL 语句都不一样，都需要编译并缓存。

大量查询的时候，首选参数化查询。

开发时，应该使用参数化查询。

注意：这里的查询字符串的缓存，不是查询结果的缓存

上下文支持：

连接类源代码：

 1 class Connection(object): # 返回一个conn
 2     def __enter__(self):
 3         """Context manager that returns a Cursor"""
 4         return self.cursor()
 6     def __exit__(self, exc, value, traceback):
 7         """On successful exit, commit. On exception, rollback"""
 8         if exc:
 9             self.rollback()
10         else:
11             self.commit()

游标类源代码：

1 class Cursor(object):
2     def __enter__(self):
3         return self
5     def __exit__(self, *exc_info):
6         del exc_info
7         self.close()

可以看出，连接类 的上下文，进入之前，conn实例，调用cursor() 方法，创建游标，结束的时候，，如果异常，回滚，如果正常，则只是提交。并没有关闭连接

游标类，进入的时候，返回游标实例，退出的时候，关闭 了游标类。

举例 1：

 1 import pymysql
 2 from pymysql.cursors import  DictCursor
 4 conn = pymysql.connect('192.168.112.111', 'root','123456', 'test')
 6 try:
 7     with conn.cursor() as cursor:
 8         sql = "select * from t1"
 9         cursor.execute(sql)
10     conn.commit()
11     # 只需要提交事务，cursor 已经在退出with的时候，就关闭了
13 except Exception as e:
14     print(e)
15     conn.rollback()    
16 finally:
17     conn.close() # 

举例 2：

 1 import pymysql
 2 from pymysql.cursors import  DictCursor
 4 conn = pymysql.connect('192.168.112.111', 'root','123456', 'test')
 7 with conn as cursor:
 8     sql = "select * from t1"
 9     cursor.execute(sql)
11 # 此外 在 __enter__ 里创建的curor 也没有关掉，所以可以继续 使用
12 sql = "select * from t2"
13 cursor.execute(sql)
15 # conn 的上下文 退出with 的时候，没有将conn 关掉
16 cursor.close()
17 conn.close()

举例 3：

 1 import pymysql
 2 from pymysql.cursors import  DictCursor
 4 conn = pymysql.connect('192.168.112.111', 'root','123456', 'test')
 7 with conn as cursor:
 8     with cursor:
 9         sql = "select * from t1"
10         cursor.execute(sql)
13 # conn 的上下文 退出with 的时候，没有将conn 关掉,但是cursor 关了
14 conn.close()

总结 ：连接不需要反反复复重建销毁，应该是多个cursor 共享一个conn