mysql整理

<!doctype html>MySQL.md

MySQL

介绍

SQL 是结构化查询语言的缩写，是一种功能齐全的数据库语言

MySQL是一个关系型数据库管理系统，是由瑞典的MySQL AB公司开发，被Oracle收购，特点是免费，开源，跨平台

安装

　　a. 安装MySQL服务端 　　b. 安装MySQL客户端 　　b. 【客户端】连接【服务端】 　　c. 【客户端】发送命令给【服务端MySQL】服务的接受命令并执行相应操作(增删改查等)

#下载
        http://dev.mysql.com/downloads/mysql/
#安装
        windows:
            #点点点
        Linux:
            yum install mysql-server
        Mac:
            #点点点

语法

  1. ​ 数据库语句是不区分大小写的
  2. ​ 自带的命令用大写，自己命名的名字用小写，，，便于区分
  3. ​ 以分号作为结束符号
  4. ​ -- 单行注释

​ /**/多行注释

  1. ​ 中括号里面的东西表示，可有可无

sql的数据类型

1. 数值类型

类型大小范围（有符号）范围（无符号）用途
TINYINT 1字节 （-128,127） （0,255） 小整数值
SMALLINT 2字节 （-32768,32767） （0,65535） 大整数值
MEDIUMINT 3字节 （-8388608,8388607） （0,16777215） 大整数值
INT或INTEGER 4字节      
BIGINT 8字节      
FlOAT 4字节     单精度浮点数
DOUBLE 8字节     双精度浮点值
DECIMAL 对DECIMAL(M,D) ，如果M>D，为M+2否则为D+2 依赖于M和D的值 依赖于M和D的值 小数值，银行会用到

​ decimal的精度比double大，所能存储的最大数比double小，decimal也存在精度损失，只是比较小

还有bit类型，bit(M) ,M的范围是1-64，不写默认是1，这种类型的数据需要使用函数读取，bin()显示为二进制，hex()显示十六进制

2. 时间类型

类型大小范围格式用途
DATE 3 1000-01-01/9999-12-31 YYYY-MM-DD 日期值
TIME 3 '-838:59:59'/'838:59:59' HH:MM:SS 时间值或持续时间
YRAE 1 1901-2155 YYYY 年份值
DATETIME 8 1000-01-01 00:00:00/9999-12-31 23:59:59 YYYY-MM-DD HH:MM:SS 混合日期和时间值
TIMESTAMP 8 1970-01-01 00:00:00/2037 年某时 YYYYMMDD HHMMSS 混合日期和时间值，时间戳

3.字符串类型

类型大小用途
CHAR 0-255字节 定长字符串
VARCHAR 0-65535字节 变长字符串
TINYBLOB 0-255字节 不超过255个字符的二进制字符串
BLOB 0-65535字节 二进制形式的长文本数据
TEXT 0-65535字节 长文本数据
MEDIUMBLOB 0-16777215字节 二进制形式的中等长度文本数据
MEDIUMTEXT 0-16 777 215字节 中等长度文本数据
LOGNGBLOB 0-4 294 967 295字节 二进制形式的极大文本数据
LONGTEXT 0-4 294 967 295字节 极大文本数据
     

 

基本命令

  • 启动MySQL

    mysql -uroot -p123				-- 登录数据库

  • 数据库的操作

    SHOW DATABASES；  --查看数据库
CREATE DATABASE database_name character set utf8 ;  -- 新建一个数据库
DROP DATABASE database_name                     -- 删除库

ALTER DATABASE database_name character set gbk;     -- 修改字符集
SHOW CREATE DATABASE database_name;         -- 查看库创建时的信息
USE  database_name                              -- 使用某个数据库

    注意

       	1. 新建数据库时，指定字符编码要用utf8,不能用utf-8
    	2. 删除数据库的命令不要记，从删库到跑路，祝你好运
     	3. 如果想修改数据库的名字，就直接从资源管理器中修改行了
     	4. 进入一个数据库后，没有命令退出，但是可以继续用USE命令切换

  • 数据表的操作

    SHOW TABLES；		-- 查看该数据库中所有的表
CREATE TABLE table_name(
          字段名字 字段数据类型【约束】，
          字段名字 字段数据类型【约束】，
          字段名字 字段数据类型【约束】，
          。。。
          字段名字 字段数据类型【约束】
     )；								-- 创建一张表
DESC table_name;					-- 查看表信息
  
SHOW COLUMNS FROM table_name -- 查看表结构，这个和上面是一样的
SHOW CREATE TABLE table_name     -- 查看当前数据库表建表语句

 /*增*/
 ALTER TABLE table_name ADD [column] 列名 类型 [完整性约束条件] [first | after 字段名]； 			-- `增加列`
 /*最后一个命令是说把这个字段加到某个字段的前面或后面*/

 /*改*/
 alter table tab_name modify 列名 类型 [完整性约束条件]［first｜after 字段名］;			-- 修改一列的类型

 alter table tab_name change [column] 列名 新列名 类型 [完整性约束条件]［first｜after 字段名］;		-- 修改列名，也可以同时修改类型

 rename table 表名 to 新表名;		-- 修改表名

 alter table 表名 character set utf8;	-- 修改表的字符集

 /*删*/
 alter table tab_name drop [column] 列名;	-- 删除一列

 drop table table_name		-- 删除表

 alter table table_name change id id int(10);	-- 删除键的自增长  


创建表的一个示例：

 ```mysql
  create table userinfo(id int primary key auto_increment,
                         name char(20),
                         birthday date,
 						salary double(8,2) unsigned,
                         resume text);
注意：
 	1. 数据库自带的字段，要大写
 	2. 用到char ,或者varchar这些类型时，要加字符串长度限制,char 可以不加
 	3. 对于性别，年龄这些长度基本固定的数据，最好用固定长度的数据类型来存值

约束条件

创建表的时候，字段后面要加约束条件，常用的约束条件有：

  1. 非空 not null
  2. 唯一 unique
  3. 主键 primary key 如果一个字段设置了非空属性和唯一性约束，那么自动识别为主键
  4. 自增 auto_increment 只有主键可以设置这个约束

添加约束条件

当然在建表的时候如何添加约束已经说过了，如果是建表之后

ALTER table emp add constraint pk_字段名 primary key(字段名);	-- 添加主键约束

alter table 表名 add constraint uq_字段名 unique(字段名)	-- 添加唯一约束

alter table 表名 add constraint FK_字段名 foreign key(字段名) reference 关联的表名（关联的字段名） 			-- 外键约束

检查约束，用来约束限制列中值的范围

alter table 表名 add constraint CK_字段名 check(条件表达式)

默认值约束：

alter table 表名 add constraint DF_字段名 default '默认值' for 字段名
		-- 其中'默认值' 是你想要设置的默认值

 

删除表约束

alter table 表名 drop constraint 约束名
	-- 约束名为你前面创建的 类似 PK_字段名 这样的名字
  • 注意如果约束是在创建表的时候创建的，则不能用命令删除

删除主键

-- 需要两步
alter table emp modify id int;	-- 先删除自增
 alter table emp drop primary key;	-- 在删除主键约束

关于主键

  1. 另一种创建方式是：

    create table table_name(id int,name varchar(20),primary key (id))

  2. 所以就可以通过这中方式来创建联合主键

    create table table_name(id int,name varchar(20),primary key (id,name))

  3. 关于主键的一些结论：

    1. 每张表只能有一个主键

    2. 每张表不一定只有一个非空且唯一的字段

    3. 如果一张表中只有一个非空且唯一的字段，那他就是主键；

      如果一张表中不止有一个非空且唯一的字段，那第一个非空唯一字段就是主键

 

表记录的操作


/*插入数据*/
INSERT [INTO] table_name (字段名称，，，) VALUES(值，，，)，
　　　　　　　　　　　　　　　　　　　　　　　　　　(值，，，)，
　　　　　　　　　　　　　　　　　　　　　　　　　　　　.......　　　　　　　　　　　　　　　　　　　　　　　　　　(值，，，)；
　　　　　　　　　　　　　　　　　　　　　　　　　　　　-- 注意插入字符串要用引号
/*修改数据*/                            
UPDATE table_name set 字段=值，字段=值。。。WHERE 子句;

/*删除*/
DELETE FROM table_name WHERE子句	-- 删除记录，不加where子句会把整个表删除

TRUNCATE TABLE table_name;		-- 删除整个表

/*查询数据*/
	1. 单表查询
    SELECT *|field1,field2, from table_name 
    	where ....				条件
    	group by .... 			分组
    	having ....				筛选
    	order by...[desc|asc]  	 排序
    	limit 					限制条数
    	;
    
    /*select 后面可以跟表达式，distinct表示去重*/

注意：

delete和truncate的区别：

1. 语法不同
2. delete后面可以加限制条件，选择删除某条记录，而truncate只能删掉整个表
3. delete 可以返回删除的数据，但是truncate不能
4. 在删除整个表的时候，delete的原理是一条一条的删除，而truncate 的原理是把整个表删掉，再新建一个同样字段的表
  • 所以，如果表中有自增长的字段，delete删除之后，新的表是从上个位置开始自增的，但是truncate是从1开始

查询

where语句

where语句中可以使用：

  1. 比较运算符 < > >= <= !=

    1. between ...and .... 在和之间

      1. in(a,b,c) 在a,b,c这三个值中的一个
      2. like 条件 模糊查找
      3. 比如，like "张%" 表示以‘张’开头
      4. like “张_” 表示以“张”开头，并且后面有一个字符，一个下划线表示一个字符
      5. 两个字符就用两个下划线
      6. 逻辑运算符 not and or
order 排序
select *|field1,field2... from tab_name order by field [Asc|Desc]

         -- Asc 升序、Desc 降序，其中asc为默认值 ORDER BY 子句应位于SELECT语句的结尾。
group by 分组查询
-- 语法:
  SELECT column_name, function(column_name)
  　　　　　　FROM table_name
  　　　　　　WHERE column_name operator value
  　　　　　　GROUP BY column_name;

  • GROUP BY 语句根据某个列对结果集进行分组。在分组的列上我们可以使用 COUNT, SUM, AVG等函数进行相关查询

  • 示例：

    select gender as 性别,count(*) as 人数 from emp group by gender;
select dep,max(age) from emp group by dep;

    注意，查询的字段后面可以跟一个名字，就是显示结果时的名字，其实是通过as，不过也可以省略

    ​ 还有这个count(*)可以改成count(1),可以提高效率

select * from emp where age in (select max(age) from emp group by dep);			-- where 后面再跟一个子查询

select dep,avg(salary) from emp group by dep having avg(salary)>8000;
			-- group by 之后再加限制条件要用having

 

concat函数

将相同的行组合起来,括号里的参数有任何一个为Null，返回值为Null

还有group_concat ,是分组后连接的，如果查询语句中没有指定分组，默认为1组

比如要查询每个部门的员工姓名，

select dep,group_concat(name) from emp group by dep;

| dep | group_concat(name)
+-----------+------------------------------+ | 保安部 | egon,李四,赵六
| 保洁部 | alex,猪七 | | 教学部 | yuan,景丽阳,张三,王五

可以拿到这样的结果

 

select group_concat(name,salary) from emp

+----------------------------------------------------------------------------------------------------+
| group_concat(name,salary)                                                                          |
+----------------------------------------------------------------------------------------------------+
| 张三8000.00,李四12000.00,王五5000.00,赵六8000.00,猪七9000.00,周八7000.00,蔡九7000.00               |
+----------------------------------------------------------------------------------------------------+

详细的介绍在这里

MySQL 字符串连接CONCAT()函数

` MySQL EXTRACT() `函数

MySQL 字符串截取SUBSTRING()函数

MySQL字符串连接函数
使用方法：
CONCAT(str1,str2,…)
返回结果为连接参数产生的字符串。如有任何一个参数为NULL ，则返回值为 NULL。
注意：
如果所有参数均为非二进制字符串，则结果为非二进制字符串。
如果自变量中含有任一二进制字符串，则结果为一个二进制字符串。
一个数字参数被转化为与之相等的二进制字符串格式；若要避免这种情况，可使用显式类型 cast, 例如：

SELECT CONCAT(CAST(int_col AS CHAR), char_col)

MySQL的concat函数可以连接一个或者多个字符串,如

mysql> select concat('10');
+--------------+
| concat('10') |
+--------------+
| 10  |
+--------------+
1 row in set (0.00 sec)
mysql> select concat('11','22','33');
+------------------------+
| concat('11','22','33') |
+------------------------+
| 112233 |
+------------------------+
1 row in set (0.00 sec)

MySQL的concat函数在连接字符串的时候，只要其中一个是NULL,那么将返回NULL

mysql> select concat('11','22',null);
+------------------------+
| concat('11','22',null) |
+------------------------+
| NULL  |
+------------------------+
1 row in set (0.00 sec)


MySQL中 concat_ws 函数
使用方法：
CONCAT_WS(separator,str1,str2,...)
CONCAT_WS() 代表 CONCAT With Separator ，是CONCAT()的特殊形式。第一个参数是其它参数的分隔符。分隔符的位置放在要连接的两个字符串之间。分隔符可以是一个字符串，也可以是其它参数。
注意：
如果分隔符为 NULL，则结果为 NULL。函数会忽略任何分隔符参数后的 NULL 值。
如连接后以逗号分隔

mysql> select concat_ws(',','11','22','33');

+-------------------------------+
| concat_ws(',','11','22','33') |
+-------------------------------+
| 11,22,33 |
+-------------------------------+
1 row in set (0.00 sec)

和MySQL中concat函数不同的是, concat_ws函数在执行的时候,不会因为NULL值而返回NULL
mysql> select concat_ws(',','11','22',NULL);
+-------------------------------+
| concat_ws(',','11','22',NULL) |
+-------------------------------+
| 11,22 |
+-------------------------------+
1 row in set (0.00 sec)


MySQL中 group_concat 函数
完整的语法如下：
group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator '分隔符'])
基本查询

mysql> select * from aa;
+------+------+
| id| name |
+------+------+
|1 | 10|
|1 | 20|
|1 | 20|
|2 | 20|
|3 | 200  |
|3 | 500  |
+------+------+
6 rows in set (0.00 sec)


以id分组，把name字段的值打印在一行，逗号分隔(默认)

mysql> select id,group_concat(name) from aa group by id;
+------+--------------------+
| id| group_concat(name) |
+------+--------------------+
|1 | 10,20,20|
|2 | 20 |
|3 | 200,500|
+------+--------------------+
3 rows in set (0.00 sec)

以id分组，把name字段的值打印在一行，分号分隔

mysql> select id,group_concat(name separator ';') from aa group by id;
+------+----------------------------------+
| id| group_concat(name separator ';') |
+------+----------------------------------+
|1 | 10;20;20 |
|2 | 20|
|3 | 200;500  |
+------+----------------------------------+
3 rows in set (0.00 sec)

以id分组，把去冗余的name字段的值打印在一行，
逗号分隔

mysql> select id,group_concat(distinct name) from aa group by id;
+------+-----------------------------+
| id| group_concat(distinct name) |
+------+-----------------------------+
|1 | 10,20|
|2 | 20  |
|3 | 200,500 |
+------+-----------------------------+
3 rows in set (0.00 sec)

以id分组，把name字段的值打印在一行，逗号分隔，以name排倒序

mysql> select id,group_concat(name order by name desc) from aa group by id;
+------+---------------------------------------+
| id| group_concat(name order by name desc) |
+------+---------------------------------------+
|1 | 20,20,10  |
|2 | 20|
|3 | 500,200|
+------+---------------------------------------+
3 rows in set (0.00 sec)

repeat函数

repeat()函数
    用来复制字符串,如下'ab'表示要复制的字符串，2表示复制的份数

mysql> select repeat('ab',2);

+----------------+
| repeat('ab',2) |
+----------------+
| abab          |
+----------------+

  1 row in set (0.00 sec)


又如

mysql> select repeat('a',2);

+---------------+
| repeat('a',2) |
+---------------+
| aa            |
+---------------+
1 row in set (0.00 sec)


mysql向表中某字段后追加一段字符串:

update table_name set field=CONCAT(field,'',str)

mysql 向表中某字段前加字符串

update table_name set field=CONCAT('str',field)

 

 

limit限制显示条数
SELECT * from emp limit 1;
SELECT * from emp limit 2,5;        --  跳过前两条显示接下来的五条纪录

 

正则表达式
SELECT * FROM employee WHERE emp_name REGEXP '^yu';

SELECT * FROM employee WHERE emp_name REGEXP 'yun$';

SELECT * FROM employee WHERE emp_name REGEXP 'm{2}';

 

 

 

mysql在执行sql语句时的执行顺序是：

 -- from where select group by having order by

 

 

 

多表查询

1.笛卡尔积查询

select * from emp,dep		-- 这样直接把两张表拼起来，很多重复的

+----+--------+----------+--------+----+-----------+ | id | name | salary | dep_id | id | name | +----+--------+----------+--------+----+-----------+ | 1 | 张三 | 8000.00 | 2 | 1 | 教学部 | | 1 | 张三 | 8000.00 | 2 | 2 | 销售部

 

这个结果对我们没有什么意义

 

内连接, inner join on

可以把id一样的加个条件限制一下：可以用表名点的方式区别

select * from emp,dep where emp.dep_id=dep.id;

这样拿到的就是我们想要的结果了

也可以写成这样：

select * from emp inner join dep on emp.dep_id=dep.id;

然后就可以在这个基础上来进行查询了

比如，查询李四所在的部门名称

 select emp.name,dep.name from emp inner join dep on emp.dep_id=dep.id where emp.name='李四';

 

外链接

可以看到，上面那两张表中，周八的部门是4，而部门表中没有这个部门，所以内连接的时候，直接省掉了这个记录，如果我们想把这个记录也显示出来，就要用外连接

1.左外链接，在内连接的基础上增加左边有，右边没有的结果

select * from emp left join dep on dep.id=emp.dep_id;

2.右外连接，在内连接的基础上增加右边有，左边没有的结果

select * from emp right join dep on dep.id=emp.dep_id;

 

权限管理

CREATE USER 'username'@'host' IDENTIFIED BY 'password';		-- 创建用户
/*username：你将创建的用户名
host：指定该用户在哪个主机上可以登陆，如果是本地用户可用localhost，如果想让该用户可以从任意远程主机登陆，可以使用通配符%
password：该用户的登陆密码，密码可以为空，如果为空则该用户可以不需要密码登陆服务器*/

select distinct concat('User:''',user,'''@''',host,''';') as query from mysql.user;			-- 查看所有用户  	

show grants for 'zhangcan'@'%';			-- 查看某个用户的权限


GRANT privileges ON databasename.tablename TO 'username'@'host'; -- 授权

/*privileges：用户的操作权限，如SELECT，INSERT，UPDATE等，如果要授予所的权限则使用ALL
databasename：数据库名
tablename：表名，如果要授予该用户对所有数据库和表的相应操作权限则可用*表示，如*.**/

/*注意，用以上命令授权的用户不能给其它用户授权，如果想让该用户可以授权，用以下命令:*/

GRANT privileges ON databasename.tablename TO 'username'@'host' WITH GRANT OPTION;		

### 设置与更改用户密码
SET PASSWORD FOR 'username'@'host' = PASSWORD('newpassword');

###如果是当前登录用户使用：
SET PASSWORD = PASSWORD("newpassword");


##撤销用户权限
REVOKE privilege ON databasename.tablename FROM 'username'@'host';


## 删除用户
DROP USER 'username'@'host';

 

 

查看数据库端口

可以用status命令

修改数据库查询的结束符

delimiter $$$$ ，就把sql命令的结束符由; 改成 $$$$ 了

mysql 的数据引擎

  • 查看引擎 ： show engines

    如果觉的显示的不好看，可以在命令后加一个 \G ,这样命令行会给你格式化一下

  • innodb是最常见的一个，支持事务，比MyISAM占更多空间

    innodb 加锁时必须用 for update

  • MyISAM ，不支持事务，也不支持外键，所以访问速度快

    支持全文搜索，支持表锁

  • 数据库锁补充：

     Innodb
                行锁：
                    # 根据主键： 找到数据
                        SELECT * FROM tb2 WHERE nid=3 FOR UPDATE;
                表锁：
                    # 根据主键： 未到数据
                        SELECT * FROM tb2 WHERE nid=30 FOR UPDATE;
                    # 根据主键： 数据不明确
                        SELECT * FROM tb2 WHERE nid<2 FOR UPDATE;
                        SELECT * FROM tb2 WHERE nid!=3 FOR UPDATE;
                    # 根据非主键查找
                        SELECT * FROM tb2 WHERE name='alex' FOR UPDATE;
            MyISAM:
                表锁：
                    A用户：
                        lock table tb1 write;
                    B用户：
                        insert into tb1(name) values('alex');
                        # 阻塞
                    A用户：
                        unlock tb1;
                    A用户：
                        lock table tb1 read;
                    B用户：
                        select * from tb1 for update;
                        # 阻塞
                    A用户：
                        unlock tb1;
注意： 
    with transaction.atomic():
        result = models.UserInfo.objects.filter(id=1).select_for_update()

  • 建表时可以指定引擎

    create table innodb_t1(id int, name char(10)) engine=innodb;

数据库索引

  • 在数据库中，索引也叫键

  • 索引优化应该是对查询性能优化最有效的手段了

  • 创建索引与维护索引会消耗很多时间和磁盘空间，但是查询速度大大提高

  • 用的最多的算法是B+树和哈希索引

  • 索引命中的

  • 创建索引：

    语法是：

        CREATE TABLE 表名 (
                字段名1  数据类型 [完整性约束条件…],
                字段名2  数据类型 [完整性约束条件…],
                [UNIQUE]   INDEX | KEY
                [索引名]  (字段名[(长度)]  [ASC |DESC])
                );

    一个示例：

    create table table_name (id int,name varchar(20),index index_emp_name(name));

    这是一个普通索引

    唯一索引：

     UNIQUE INDEX index_emp_name (name)

    全文索引：

    FULLTEXT INDEX index_resume (resume)

    多列索引

    INDEX index_name_resume (name,resume)

  • 在已存在的表上添加索引,有两种方法

     CREATE  [UNIQUE]  INDEX  索引名
              ON 表名 (字段名[(长度)]  [ASC |DESC]) ;

     ALTER TABLE 表名 ADD  [UNIQUE] INDEX
                    索引名 (字段名[(长度)]  [ASC |DESC]) ;

  • 删除索引

    语法：DROP INDEX 索引名 on 表名

Django中的mysql

 

配置

默认Django中使用的数据库是sqllite，如果要用mysql，需要修改配置

DATABASES = {

    'default': {

        'ENGINE': 'django.db.backends.mysql',

        'NAME': 'books',    #你的数据库名称

        'USER': 'root',   #你的数据库用户名

        'PASSWORD': '', #你的数据库密码

        'HOST': '', #你的数据库主机，留空默认为localhost

        'PORT': '3306', #你的数据库端口
    }

}

除此之外，

py2中，django 默认的数据库驱动是MySQLdb，但是Python3版本就是sqlpy了，所以还需要在项目根目录下的__init__文件中，添加以下配置

import pymysql

pymysql.install_as_MySQLdb()

 

 

pymysql模块

这是Python中操作MySQL的模块，其使用方法和MySQLdb几乎一致

首先，要改楼上那个配置

1、执行SQL

import pymysql
  
# 创建连接
conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='123', db='t1')
# 创建游标,一切操作都要通过这个游标
cursor = conn.cursor()
  
# 执行SQL，并返回收影响行数
effect_row = cursor.execute("update hosts set host = '1.1.1.2'")
  
# 执行SQL，并返回受影响行数
#effect_row = cursor.execute("update hosts set host = '1.1.1.2' where nid > %s", (1,))
  
# 执行SQL，并返回受影响行数
#effect_row = cursor.executemany("insert into hosts(host,color_id)values(%s,%s)", [("1.1.1.11",1),("1.1.1.11",2)])
  
  
# 提交，不然无法保存新建或者修改的数据
conn.commit()
  
# 关闭游标
cursor.close()
# 关闭连接
conn.close()

2、获取新创建数据自增ID

import pymysql
  
conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='123', db='t1')
cursor = conn.cursor()
cursor.executemany("insert into hosts(host,color_id)values(%s,%s)", [("1.1.1.11",1),("1.1.1.11",2)])
conn.commit()
cursor.close()
conn.close()
  
# 获取最新自增ID
new_id = cursor.lastrowid

3、获取查询数据

import pymysql
  
conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='123', db='t1')
cursor = conn.cursor()
cursor.execute("select * from hosts")
  
# 获取第一行数据
row_1 = cursor.fetchone()
  
# 获取前n行数据
# row_2 = cursor.fetchmany(3)
# 获取所有数据
# row_3 = cursor.fetchall()
  
conn.commit()
cursor.close()
conn.close()

注：在fetch数据时按照顺序进行，可以使用cursor.scroll(num,mode)来移动游标位置，如：

  • cursor.scroll(1,mode='relative') # 相对当前位置移动
  • cursor.scroll(2,mode='absolute') # 相对绝对位置移动

4、fetch数据类型

关于默认获取的数据是元祖类型，如果想要或者字典类型的数据，即：

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)
r = cursor.execute("call p1()")
  
result = cursor.fetchone()
  
conn.commit()
cursor.close()
conn.close()

 

SQLAchemy

SQLAlchemy是Python编程语言下的一款ORM框架，该框架建立在数据库API之上，使用关系对象映射进行数据库操作，简言之便是：将对象转换成SQL，然后使用数据API执行SQL并获取执行结果。

posted @ 2017-12-15 21:28  张璨  阅读(88)  评论(0)    收藏  举报