day20——安装客户端数据库连接mysql事务mysql操作数据

Posted 2020-10-15 落后乞丐

python的mysql操作

mysql数据库是最流行的数据库之一,所以对于python操作mysql的了解是必不可少的。Python标准数据库接口为Python DB-API, Python DB-API为开发人员提供了数据库应用 编程接口。参考地址：https://wiki.python.org/moin/DatabaseInterfaces，你可以查看python支持数据库的详细列表。不同的数据库需要下载不同的DB API模块。DB-API是一个规范。它定义了一系列必须的对象和数据库存取方式, 以便为各种各样的底层数据库系统和多种多样的数据库接口程序提供一致的访问接口。Python的DB-API,为大多数的数据库实现了接口,使用它连接各数据库后,就可以用相同 的方式操作各数据库。

Python DB-API使用流程:

1. 引入API模块。
2. 获取与数据库的连接。
3. 执行SQL语句和存储过程。
4. 关闭数据库连接。

安装所需要的包

MySQLdb 是用于Python链接Mysql数据库的接口，它实现了 Python 数据库 API 规范 V2.0，基于 MySQL C API 上建立的。

如果是windows系统：登录https://pypi.python.org/pypi/MySQL-python/1.2.5找到.exe结尾的包，下载安装就好了，然后在cmd中执行：

 

如果结果如上图所示，就说明你安装成功了，如果有如下报错信息，

>>> import MySQLdb

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

ImportError: No module named MySQLdb

那是环境变量有问题，把安装刚才下载的.exe包的路径添加到环境变量中就可以了。

如果是linux或者其他系统，可以下载源码包进行安装：上节链接中的zip包，然后安装：

yum install –y python-devel

yum install –y mysql-devel

yum install –y gcc

unzip MySQL-python-1.2.5.zip

cd MySQL-python-1.2.5

python setup.py build

python setup.py install

python

>>> import MySQLdb

/usr/lib64/python2.7/site-packages/MySQL_python-1.2.5-py2.7-linux-x86_64.egg/_mysql.py:3: UserWarning: Module _mysql was already imported from /usr/lib64/python2.7/site-packages/MySQL_python-1.2.5-py2.7-linux-x86_64.egg/_mysql.pyc, but /usr/local/src/MySQL-python-1.2.5 is being added to sys.path

如果出现类似的错误，原因是，install后MySQLdb模块已经被放到python的site-pachages目录中；但我在当前目录也存在相同的模块，所以可能会重复导入。只要切换到其他目录运行python就可以了。

在linux服务器上安装mysql-server，我安装的是mysql5.6

yum install -y mysql-community-server-5.6.34-2.el7.x86_64

centos7版本以前：service mysqld restart

centos7版本以后：systemctl restart mysql.service

mysql进行授权:

mysql

create database python;

grant all privileges on *.* \'wxp\'@\'%\' identified by \'123456\';

flush privileges;

解释：

Mysql命令进入mysql数据库，create用来创建库名python，grant 进行授权，授权xiang用户对所有的服务器，所有的库，所有的表都有权限，密码123456。

连接数据库

 1 import MySQLdb
 2 #连接数据库
 3 #host s数据库ip
 4 #port 数据库监听的端口
 5 #user 数据库用户名
 6 #passwd 数据库密码
 7 #db 数据库名称
 8 #charset 数据库字符编码，常用utf-8
 9 #模块的化的思想，尽可能让代码模块化
10 
11 def connect_mysql():
12     db_config = {
13         "host": "192.168.1.5",
14         "user": "wxp",
15         "passwd": "1qazxsw@",
16         "db": "python"
17         "charset": "utf-8"
18     }
19     try:
20         cnx = MySQLdb.connect(**db_config)
21     except Exception as e:
22         raise e
23     return cnx

 

　　mysql事务MySQL 事务主要用于处理操作量大，复杂度高的数据。比如，你操作一个数据库，公司的一个员工离职了，你要在数据库中删除他的资料，也要删除该人员相关的，比如邮箱，个人资产等。这些数据库操作语言就构成了一个事务。
在MySQL中只有使用了Innodb数据库引擎的数据库或表才支持事务，所以很多情况下我们都使用innodb引擎。
事务处理可以用来维护数据库的完整性，保证成批的SQL语句要么全部执行，要么全部不执行。
一般来说，事务是必须满足4个条件（ACID）： Atomicity（原子性）、Consistency（稳定性）、Isolation（隔离性）、Durability（可靠性）

1、事务的原子性：一组事务，要么成功；要么撤回。
2、稳定性 ： 有非法数据（外键约束之类），事务撤回。
3、隔离性：事务独立运行。一个事务处理后的结果，影响了其他事务，那么其他事务会撤回。事务的100%隔离，需要牺牲速度。
4、可靠性：软、硬件崩溃后，InnoDB数据表驱动会利用日志文件重构修改。可靠性和高速度不可兼得， innodb_flush_log_at_trx_commit选项 决定什么时候吧事务保存到日志里。
而mysql在默认的情况下，他是把每个select，insert，update，delete等做为一个事务的，登录mysql服务器，进入mysql，执行以下命令：
mysql> show variables like \'auto%\';
+--------------------------+-------+
| Variable_name | Value |
+--------------------------+-------+
| auto_increment_increment | 1 |
| auto_increment_offset | 1 |
| autocommit | ON |
| automatic_sp_privileges | ON |
+--------------------------+-------+
4 rows in set (0.00 sec)
如上所示： 有一个参数autocommit就是自动提交的意思，每执行一个msyql的select，insert，update等操作，就会进行自动提交。
如果把改选项关闭，我们就可以每次执行完一次代码就需要进行手动提交，connect对象给我们提供了两种办法来操作提交数据。
d) mysql事务的方法
commit():提交当前事务，如果是支持事务的数据库执行增删改后没有commit则数据库默认回滚，白操作了
rollback():取消当前事务
下面我们来看个例子：
我们先创建一个员工表：
create table employees (
emp_no int not null auto_increment,
emp_name varchar(16) not null,
gender enum(\'M\', \'F\') not null,
hire_date date not null,
primary key (emp_no)
);
其中，emp_no为员工id，为主键且唯一
emp_name为：员工的名字
fender为：性别，只有M和F两种选择
hire_date为：雇佣的时间。
为了试验的效果，我们插入几条数据：
insert into employees(emp_no, emp_name, gender, hire_date) values(1001, \'lingjiang\', \'M\', \'2015-04-01\');
insert into employees(emp_no, emp_name, gender, hire_date) values(1002, \'xiang\', \'M\', \'2015-04-01\');
insert into employees(emp_no, emp_name, gender, hire_date) values(1003, \'shang\', \'M\', \'2015-04-01\');
mysql> select * from employees;
+--------+-----------+--------+------------+
| emp_no | emp_name | gender | hire_date |
+--------+-----------+--------+------------+
| 1001 | lingjiang | M | 2015-04-01 |
| 1002 | xiang | M | 2015-04-01 |
| 1003 | shang | M | 2015-04-01 |
+--------+-----------+--------+------------+
e) rows in set (0.00 sec)

 游标操作

我们先来看一个例子：

接下来，我们通过python代码增加一条数据到数据库中，代码如下：

 

 1 import MySQLdb
 2 
 3 def connect_mysql():
 4 
 5     db_config = {
 6 
 7         \'host\': \'192.168.48.128\',
 8 
 9         \'port\': 3306,
10 
11         \'user\': \'xiang\',
12 
13         \'passwd\': \'123456\',
14 
15         \'db\': \'python\',
16 
17         \'charset\': \'utf8\'
18 
19     }
20 
21     cnx = MySQLdb.connect(**db_config)
22 
23     return cnx
24 
25 if __name__ == \'__main__\':
26 
27     cnx = connect_mysql()
28 
29     cus = cnx.cursor()
30 
31     sql  = \'\'\' create table test(id int not null);insert into test(id) values (100);\'\'\'
32 
33     try:
34 
35         cus.execute(sql)
36 
37 cus.close()
38 
39         cnx.commit()
40 
41     except Exception as e:
42 
43         cnx.rollback()
44 
45         print(\'Error\')
46 
47         # raise e
48 
49     finally:
50 
51         cnx.close()

 

结果：

Error

 

查看数据库中的数据：select * from employees;并没有发生变化

解释：

在我们插入数据雇佣时间字段：hire_date的时候，故意把时间写错，导致异常发生，捕获到异常之后，打印Error，最后关闭mysql连接。cus = cnx.cursor()是创建一个游标对象，具体我们在后面进行介绍。

1，  创建游标对象

 

 1 Import MySQLdb
 2 
 3  db_config = {
 4 
 5         \'host\': \'192.168.48.128\',
 6 
 7         \'port\': 3306,
 8 
 9         \'user\': \'wxp\',
10 
11         \'passwd\': \'123456\',
12 
13         \'db\': \'python\',
14 
15         \'charset\': \'utf8\'
16 
17     }
18 
19 cnx = MySQLdb.connect(**db_config)
20 
21 cus = cnx.cursor()

 

这样就是创建一个游标对象，以后我们对mysql的各种操作都是基于游标进行操作，后面我们将详细介绍。

 

在了解该方法之前，我们先来了解什么叫做游标，

 

游标（cursor）

 

　　游标是系统为用户开设的一个数据缓冲区，存放SQL语句的执行结果

 

　　用户可以用SQL语句逐一从游标中获取记录，并赋给主变量，交由python进一步处理，一组主变量一次只能存放一条记录

 

　　仅使用主变量并不能完全满足SQL语句向应用程序输出数据的要求

 

　　1.游标和游标的优点

 

在数据库中，游标是一个十分重要的概念。游标提供了一种对从表中检索出的数据进行操作的灵活手段，就本质而言，游标实际上是一种能从包括多条数据记录的结果集中每次提取一条记录的机制。游标总是与一条SQL 选择语句相关联因为游标由结果集（可以是零条、一条或由相关的选择语句检索出的多条记录）和结果集中指向特定记录的游标位置组成。当决定对结果集进行处理时，必须声明一个指向该结果集的游标。

常用方法:

cursor():创建游标对象
       close():关闭此游标对象
       fetchone():得到结果集的下一行
       fetchmany([size = cursor.arraysize]):得到结果集的下几行
       fetchall():得到结果集中剩下的所有行
       excute(sql[, args]):执行一个数据库查询或命令
       executemany (sql, args):执行多个数据库查询或命令

下面我们来看一个例子：

 1 import MySQLdb
 2 
 3 def connect_mysql():
 4 
 5     db_config = {
 6 
 7         \'host\': \'192.168.48.128\',
 8 
 9         \'port\': 3306,
10 
11         \'user\': \'xiang\',
12 
13         \'passwd\': \'123456\',
14 
15         \'db\': \'python\',
16 
17         \'charset\': \'utf8\'
18 
19     }
20 
21     cnx = MySQLdb.connect(**db_config)
22 
23     return cnx
24 
25 if __name__ == \'__main__\':
26 
27     cnx = connect_mysql()
28 
29     cus = cnx.cursor()
30 
31     sql  = \'\'\'select * from employees;\'\'\'
32 
33     try:
34 
35         cus.execute(sql)
36 
37         result1 = cus.fetchone()
38 
39         print(\'result1:\')
40 
41         print(result1)
42 
43         result2 = cus.fetchmany(1)
44 
45         print(\'result2:\')
46 
47         print(result2)
48 
49         result3 = cus.fetchall()
50 
51         print(\'result3:\')
52 
53         print(result3)        cus.close()
54 
55         cnx.commit()
56 
57     except Exception as e:
58 
59         cnx.rollback()
60 
61         print(\'error\')
62 
63         raise e
64 
65     finally:
66 
67         cnx.close()

 

结果：

result1:

(1001L, u\'lingjiang\', u\'M\', datetime.date(2015, 4, 1))

result2:

((1002L, u\'xiang\', u\'M\', datetime.date(2015, 4, 1)),)

result3:

((1003L, u\'shang\', u\'M\', datetime.date(2015, 4, 1)),)

解释：

1，  先通过MySQLdb.connect(**db_config)建立mysql连接对象

2，  在通过 = cnx.cursor()创建游标

3，  fetchone():在最终搜索的数据中去一条数据

4，  fetchmany(1)在接下来的数据中在去1行的数据，这个数字可以自定义，定义多少就是在结果集中取多少条数据。

5，  fetchall()是在所有的结果中搞出来所有的数据。

对于excute()和excutemany()的方法，我们会在以一节详细分析他们的区别。

执行多条语句的sql时要注意：

 

 1 from demon2 import connect_mysql
 2 
 3 import MySQLdb
 4 
 5 def connect_mysql():
 6 
 7     db_config = {
 8 
 9         "host": "192.168.48.128",
10 
11         "port": 3306,
12 
13         "user": "xiang",
14 
15         "passwd": "123456",
16 
17         "db": "python",
18 
19         "charset": "utf8"
20 
21     }
22 
23     try:
24 
25         cnx = MySQLdb.connect(**db_config)
26 
27     except Exception as e:
28 
29         raise e
30 
31     return cnx
32 
33 if __name__ == "__main__":
34 
35     sql = "select * from tmp;"
36 
37     sql1 = "insert into tmp(id) value (%s);"
38 
39     param = []
40 
41     for i in xrange(100, 130):
42 
43         param.append([str(i)])
44 
45     print(param)
46 
47     cnx = connect_mysql()
48 
49     cus = cnx.cursor()
50 
51     print(dir(cus))
52 
53     try:
54 
55         cus.execute(sql)
56 
57         cus.executemany(sql1, param)
58 
59         # help(cus.executemany)
60 
61         result1 = cus.fetchone()
62 
63         print("result1")
64 
65         print(result1) 
66 
67         result2 = cus.fetchmany(3)
68 
69         print("result2")
70 
71         print(result2)
72 
73         result3 = cus.fetchall()
74 
75         print("result3")
76 
77         print(result3)
78 
79         cus.close()
80 
81         cnx.commit()
82 
83     except Exception as e:
84 
85         cnx.rollback()
86 
87         raise e
88 
89     finally:
90 
91         cnx.close()