Python 12：mysql

2、数据库基本操作

3、表操作

4、表内容操作

5、视图

6、事务

7、索引

8、pyMySQL

9、sqlalchemy ORM

一、数据库基础

1、关系型数据库

小型关系型数据库软件：MySql、SqlServer/Access、maridb(从原Mysql出来的人马组建的)

大型关系型数据库：Oracle、DB2/Infomix

非关系型数据库，比如云计算大数据所用的mongoDB

目前金融行业oracle占65%-70%，DB2占10%，informix占10%，光大银行180套系统全都是用的oracle，中银用的ORA+DB2，建行用的informix

2、术语

数据库: 数据库是一些关联表的集合。.

数据表: 表是数据的矩阵。在一个数据库中的表看起来像一个简单的电子表格。

列: 一列(数据元素) 包含了相同的数据, 例如邮政编码的数据。

行：一行（=元组，或记录）是一组相关的数据，例如一条用户订阅的数据。

冗余：存储两倍数据，冗余可以使系统速度更快。

主键：主键是唯一的。一个数据表中只能包含一个主键。你可以使用主键来查询数据。

外键：外键用于关联两个表。

复合键：复合键（组合键）将多个列作为一个索引键，一般用于复合索引。

索引：使用索引可快速访问数据库表中的特定信息。索引是对数据库表中一列或多列的值进行排序的一种结构。类似于书籍的目录。

参照完整性: 参照的完整性要求关系中不允许引用不存在的实体。与实体完整性是关系模型必须满足的完整性约束条件，目的是保证数据的一致性。

二、数据库基本操作（mysql）

1、启动mysql

启动mysql服务：service mysqld start

查看监听状态：ss -tanl |grep :3306

账号登陆：mysql -u root -p 123456

2、显示数据库

show databases; 列出数据库管理系统的数据库列表。

默认数据库：
　　mysql - 用户权限相关数据
　　test - 用于用户测试数据
　　information_schema - MySQL本身架构相关数据

3、创建数据库

create database 数据库名称 charset "utf8";  创建一个数据库，且让其支持中文编码格式(utf8)

4、使用数据库

use mysql; 选择要操作的Mysql数据库，使用该命令后所有Mysql命令都只针对该数据库。

desc user;  显示表结构

5、显示当前使用的数据库中的信息

show tables; 显示指定数据库的所有表，使用该命令前需要使用 use命令来选择要操作的数据库。

show columns from 数据表; 显示数据表的属性，属性类型，主键信息 ，是否为 NULL，默认值等其他信息。

show index from 数据表; 显示数据表的详细索引信息，包括PRIMARY KEY（主键）。

6、删除数据库

drop database testdb; #删除数据库

7、用户管理

创建用户：create user ‘用户名‘@‘IP地址‘ identified by ‘密码‘;

删除用户：drop user ‘用户名‘@‘IP地址‘;

修改用户：rename user ‘用户名‘@‘IP地址‘; to ‘新用户名‘@‘IP地址‘;

修改密码：set password for ‘用户名‘@‘IP地址‘ = Password(‘新密码‘);

用户权限相关数据保存在mysql数据库的user表中，所以也可以直接对其进行操作（不建议）

8、权限管理

show grants for ‘用户‘@‘IP地址‘                  -- 查看权限

grant 权限 on 数据库.表 to ‘用户‘@‘IP地址‘      -- 授权

revoke 权限 on 数据库.表 from ‘用户‘@‘IP地址‘      -- 取消权限

 1 #权限
 2 ‘‘‘
 3 all privileges  除grant外的所有权限
 4         select          仅查权限
 5         select,insert   查和插入权限
 6         ...
 7         usage                   无访问权限
 8         alter                   使用alter table
 9         alter routine           使用alter procedure和drop procedure
10         create                  使用create table
11         create routine          使用create procedure
12         create temporary tables 使用create temporary tables
13         create user             使用create user、drop user、rename user和revoke  all privileges
14         create view             使用create view
15         delete                  使用delete
16         drop                    使用drop table
17         execute                 使用call和存储过程
18         file                    使用select into outfile 和 load data infile
19         grant option            使用grant 和 revoke
20         index                   使用index
21         insert                  使用insert
22         lock tables             使用lock table
23         process                 使用show full processlist
24         select                  使用select
25         show databases          使用show databases
26         show view               使用show view
27         update                  使用update
28         reload                  使用flush
29         shutdown                使用mysqladmin shutdown(关闭MySQL)
30         super                   ????使用change master、kill、logs、purge、master和set global。还允许mysqladmin????????调试登陆
31         replication client      服务器位置的访问
32         replication slave       由复制从属使用
33 ‘‘‘
34 #目标数据库以及内部其他：
35 ‘‘‘
36         数据库名.*           数据库中的所有
37         数据库名.表          指定数据库中的某张表
38         数据库名.存储过程    指定数据库中的存储过程
39         *.*                 所有数据库
40 ‘‘‘
41 #用户和ip
42 ‘‘‘
43         用户名@IP地址        用户只能在改IP下才能访问
44         用户名@192.168.1.%   用户只能在改IP段下才能访问(通配符%表示任意)
45         用户名@%             用户可以再任意IP下访问(默认IP地址为%)
46 ‘‘‘
47 #示例
48 ‘‘‘
49 grant all privileges on zzdb.student to ‘用户名‘@‘IP‘
50 grant select on zzdb.* to ‘用户名‘@‘IP‘
51 grant select,insert on *.* to ‘用户名‘@‘IP‘
52 revoke select on zzdb.student from ‘用户名‘@‘IP‘
53 ‘‘‘

示例

flush privileges；  刷新用户系统权限

三、数据表基本操作（mysql）

1、创建表

create table 表名(
列名 类型 是否可以为空，
列名 类型 是否可以为空
)ENGINE=InnoDB DEFAULT CHARSET=utf8

例：

create table student(
　　stu_id INT NOT NULL AUTO_INCREMENT,
　　name CHAR(32) NOT NULL,
　　age INT NOT NULL,
　　register_date DATE,
　　PRIMARY KEY ( stu_id ))
ENGINE=InnoDB
DEFAULT CHARSET=utf8;

 1 #是否为空
 2 ‘‘‘
 3     not null    - 不可空
 4     null        - 可空
 5 ‘‘‘
 6 #默认值
 7 ‘‘‘
 8     创建列时可以指定默认值，当插入数据时如果未主动设置，则自动添加默认值
 9         create table tb1(
10             id int not null defalut 2,
11             num int not null
12         )
13 ‘‘‘
14 #自增
15 ‘‘‘
16 如果为某列设置自增列，插入数据时无需设置此列，默认将自增（表中只能有一个自增列）
17     create table tb1(
18         id int not null auto_increment primary key,
19         num int null
20     )
21     或
22     create table tb1(
23         nid int not null auto_increment,
24         num int null,
25         index(nid)
26     )
27     注意：1、对于自增列，必须是索引（含主键）。
28          2、对于自增可以设置步长和起始值
29              show session variables like ‘auto_inc%‘;
30              set session auto_increment_increment=2;
31              set session auto_increment_offset=10;
32
33              shwo global  variables like ‘auto_inc%‘;
34              set global auto_increment_increment=2;
35              set global auto_increment_offset=10;
36 ‘‘‘
37 #主键
38 ‘‘‘
39 主键，一种特殊的唯一索引，不允许有空值，如果主键使用单个列，则它的值必须唯一，如果是多列，则其组合必须唯一。
40     create table tb1(
41         nid int not null auto_increment primary key,
42         num int null
43     )
44     或
45     create table tb1(
46         nid int not null,
47         num int not null,
48         primary key(nid,num)
49     )
50 ‘‘‘
51 #外键
52 ‘‘‘
53 外键，一个特殊的索引，只能是指定内容
54     creat table color(
55         nid int not null primary key,
56         name char(16) not null
57     )
58
59     create table fruit(
60         nid int not null primary key,
61         smt char(32) null ,
62         color_id int not null,
63         constraint fk_cc foreign key (color_id) references color(nid)
64     )
65 ‘‘‘

参数

2、删除表

drop table 表名

3、清空表

delete from 表名

truncate table 表名

4、修改表

添加列：alter table 表名 add 列名 类型
删除列：alter table 表名 drop column 列名
修改列：alter table 表名 modify column 列名 类型; -- 类型
alter table 表名 change 原列名 新列名 类型; -- 列名，类型
添加主键：alter table 表名 add primary key(列名);
删除主键：alter table 表名 drop primary key;
alter table 表名 modify 列名 int, drop primary key;
添加外键：alter table 从表 add constraint 外键名称（形如：FK_从表_主表） foreign key 从表(外键字段) references 主表(主键字段);
删除外键：alter table 表名 drop foreign key 外键名称
修改默认值：ALTER TABLE testalter_tbl ALTER i SET DEFAULT 1000;
删除默认值：ALTER TABLE testalter_tbl ALTER i DROP DEFAULT;

5、基本数据类型

MySQL的数据类型大致分为：数值、时间和字符串

 1 bit：
 2     二进制位（101001），m表示二进制位的长度（1-64），默认m＝1
 3 tinyint：
 4     小整数，数据类型用于保存一些范围的整数数值范围：
 5     有符号：-128 ～ 127.
 6     无符号：0 ～ 255
 7     特别的： MySQL中无布尔值，使用tinyint(1)构造。
 8 int：
 9     整数，数据类型用于保存一些范围的整数数值范围：
10     有符号：-2147483648 ～ 2147483647
11     无符号：0 ～ 4294967295
12     特别的：整数类型中的m仅用于显示，对存储范围无限制。例如： int(5),当插入数据2时，select 时数据显示为： 00002
13 bigint：
14     大整数，数据类型用于保存一些范围的整数数值范围：
15     有符号： -9223372036854775808 ～ 9223372036854775807
16     无符号：0 ～  18446744073709551615
17 decimal：
18     准确的小数值，m是数字总个数（负号不算），d是小数点后个数。 m最大值为65，d最大值为30。
19     特别的：对于精确数值计算时需要用此类型
20            decaimal能够存储精确值的原因在于其内部按照字符串存储。
21 FLOAT：
22     单精度浮点数（非准确小数值），m是数字总个数，d是小数点后个数。
23     无符号：
24         -3.402823466E+38 to -1.175494351E-38,
25         1.175494351E-38 to 3.402823466E+38
26     有符号：
27         1.175494351E-38 to 3.402823466E+38
28     **** 数值越大，越不准确 ****
29 DOUBLE[(M,D)] [UNSIGNED] [ZEROFILL]
30     双精度浮点数（非准确小数值），m是数字总个数，d是小数点后个数。
31     无符号：
32         -1.7976931348623157E+308 to -2.2250738585072014E-308
33         2.2250738585072014E-308 to 1.7976931348623157E+308
34     有符号：
35         2.2250738585072014E-308 to 1.7976931348623157E+308
36     **** 数值越大，越不准确 ****
37 char (m)
38     char数据类型用于表示固定长度的字符串，可以包含最多达255个字符。其中m代表字符串的长度。
39     PS: 即使数据小于m长度，也会占用m长度
40 varchar(m)
41     varchars数据类型用于变长的字符串，可以包含最多达255个字符。其中m代表该数据类型所允许保存的字符串的最大长度，只要长度小于该最大值的字符串都可以被保存在该数据类型中。
42     注：虽然varchar使用起来较为灵活，但是从整个系统的性能角度来说，char数据类型的处理速度更快，有时甚至可以超出varchar处理速度的50%。因此，用户在设计数据库时应当综合考虑各方面的因素，以求达到最佳的平衡
43 text
44     text数据类型用于保存变长的大字符串，可以组多到65535 (2**16 ? 1)个字符。
45 mediumtext
46     A TEXT column with a maximum length of 16,777,215 (2**24 ? 1) characters.
47 longtext
48     A TEXT column with a maximum length of 4,294,967,295 or 4GB (2**32 ? 1) characters.
49 enum
50     枚举类型，
51     An ENUM column can have a maximum of 65,535 distinct elements. (The practical limit is less than 3000.)
52     示例：
53         CREATE TABLE shirts (
54             name VARCHAR(40),
55             size ENUM(‘x-small‘, ‘small‘, ‘medium‘, ‘large‘, ‘x-large‘)
56         );
57         INSERT INTO shirts (name, size) VALUES (‘dress shirt‘,‘large‘), (‘t-shirt‘,‘medium‘),(‘polo shirt‘,‘small‘);
58 set
59     集合类型
60     A SET column can have a maximum of 64 distinct members.
61     示例：
62         CREATE TABLE myset (col SET(‘a‘, ‘b‘, ‘c‘, ‘d‘));
63         INSERT INTO myset (col) VALUES (‘a,d‘), (‘d,a‘), (‘a,d,a‘), (‘a,d,d‘), (‘d,a,d‘);
64 DATE
65     YYYY-MM-DD（1000-01-01/9999-12-31）
66 TIME
67     HH:MM:SS（‘-838:59:59‘/‘838:59:59‘）
68 YEAR
69     YYYY（1901/2155）
70 DATETIME
71     YYYY-MM-DD HH:MM:SS（1000-01-01 00:00:00/9999-12-31 23:59:59    Y）
72 TIMESTAMP
73     YYYYMMDD HHMMSS（1970-01-01 00:00:00/2037 年某时）

数据类型

四、表内容操作

 1、增

insert into 表 (列名,列名...) values (值,值,值...)
insert into 表 (列名,列名...) values (值,值,值...),(值,值,值...)
insert into 表 (列名,列名...) select (列名,列名...) from 表

2、删

delete from 表
delete from 表 where id＝1 and name＝‘zz‘

3、改

update 表 set name ＝ ‘zz‘ where id>1

4、查

select * from 表
select * from 表 where id > 1
select id,name,gender as gg from 表 where id > 1

5、其他

 1 a、条件
 2 　　select * from 表 where id > 1 and name != ‘alex‘ and num = 12;
 3 　　select * from 表 where id between 5 and 16;
 4 　　select * from 表 where id in (11,22,33)
 5 　　select * from 表 where id not in (11,22,33)
 6 　　select * from 表 where id in (select nid from 表)
 7 b、通配符
 8 　　select * from 表 where name like ‘aa%‘ - aa开头的所有（多个字符串）
 9 　　select * from 表 where name like ‘aa_‘ - aa开头的所有（一个字符）
10 c、限制
11 　　select * from 表 limit 5; - 前5行
12 　　select * from 表 limit 4,5; - 从第4行开始的5行
13 　　select * from 表 limit 5 offset 4 - 从第4行开始的5行
14 d、排序
15 　　select * from 表 order by 列 asc - 根据 “列” 从小到大排列
16 　　select * from 表 order by 列 desc - 根据 “列” 从大到小排列
17 　　select * from 表 order by 列1 desc,列2 asc - 根据 “列1” 从大到小排列，如果相同则按列2从小到大排序
18 e、分组
19 　　select num from 表 group by num
20 　　select num,nid from 表 group by num,nid
21 　　select num,nid from 表 where nid > 10 group by num,nid order nid desc
22 　　select num,nid,count(*),sum(score),max(score),min(score) from 表 group by num,nid
23 　　select num from 表 group by num having max(id) > 10
24 　　特别的：group by 必须在where之后，order by之前
25 f、连表
26 　　无对应关系则不显示
27 　　select A.num, A.name, B.name
28 　　from A,B
29 　　Where A.nid = B.nid
30 　　无对应关系则不显示
31 　　select A.num, A.name, B.name
32 　　from A inner join B
33 　　on A.nid = B.nid
34 　　A表所有显示，如果B中无对应关系，则值为null
35 　　select A.num, A.name, B.name
36 　　from A left join B
37 　　on A.nid = B.nid
38 　　B表所有显示，如果B中无对应关系，则值为null
39 　　select A.num, A.name, B.name
40 　　from A right join B
41 　　on A.nid = B.nid
42 g、组合
43 　　组合，自动处理重合
44 　　select nickname
45 　　from A
46 　　union
47 　　select name
48 　　from B
49 　　组合，不处理重合
50 　　select nickname
51 　　from A
52 　　union all
53 　　select name
54 　　from B

其他

五、视图

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

SELECT * FROM (SELECT id,NAME FROM tb1 WHERE id > 2) AS A WHERE A. NAME > ‘zz‘;  #临时表搜索

创建视图：CREATE VIEW v1 AS SELET nid,name FROM A WHERE id > 4

删除视图：DROP VIEW v1

修改视图：

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

使用视图：select * from v1

六、事务

MySQL 事务主要用于处理操作量大，复杂度高的数据。比如说，在人员管理系统中，你删除一个人员，你即需要删除人员的基本资料，也要删除和该人员相关的信息，如信箱，文章等等，这样，这些数据库操作语句就构成一个事务！

在MySQL中只有使用了Innodb数据库引擎的数据库或表才支持事务

事务处理可以用来维护数据库的完整性，保证成批的SQL语句要么全部执行，要么全部不执行

事务用来管理insert,update,delete语句

一般来说，事务是必须满足4个条件（ACID）： Atomicity（原子性）、Consistency（稳定性）、Isolation（隔离性）、Durability（可靠性）

1、事务的原子性：一组事务，要么成功；要么撤回。

2、稳定性 ： 有非法数据（外键约束之类），事务撤回。

3、隔离性：事务独立运行。一个事务处理后的结果，影响了其他事务，那么其他事务会撤回。事务的100%隔离，需要牺牲速度。

4、可靠性：软、硬件崩溃后，InnoDB数据表驱动会利用日志文件重构修改。可靠性和高速度不可兼得， innodb_flush_log_at_trx_commit选项 决定什么时候把事务保存到日志里。

控制台操作：

mysql> begin； ＃开始一个事务
mysql> insert into a (a) values(555)
mysql>rollback; 回滚 ， 这样数据是不会写入的
当然如果上面的数据没问题，就输入commit提交命令就行；

七、索引

MySQL索引的建立对于MySQL的高效运行是很重要的，索引可以大大提高MySQL的检索速度。
实际上，索引也是一张表，该表保存了主键与索引字段，并指向实体表的记录。
缺点：过多的使用索引将会造成滥用,虽然索引大大提高了查询速度，同时却会降低更新表的速度，
因为更新表时，MySQL不仅要保存数据，还要保存一下索引文件,建立索引会占用磁盘空间的索引文件。

MySQL中常见索引有：普通索引、唯一索引、主键索引、组合索引

1、普通索引：

普通索引仅有一个功能：加速查询

创建表时加入索引：

create table in1(
nid int not null auto_increment primary key,
name varchar(32) not null,
email varchar(64) not null,
extra text,
index ix_name (name)
)

创建索引：create index index_name on table_name(column_name)
删除索引：drop index_name on table_name;
查看索引：show index from table_name;
对于创建索引时如果是BLOB 和 TEXT 类型，必须指定length。
create index ix_extra on in1(extra(32));

操作

2、唯一索引

唯一索引有两个功能：加速查询 和 唯一约束（可含null）

创建表+唯一索引
create table in1(
    nid int not null auto_increment primary key,
    name varchar(32) not null,
    email varchar(64) not null,
    extra text,
    unique ix_name (name)
)
创建：create unique index 索引名 on 表名(列名)
删除：drop unique index 索引名 on 表名

操作

3、主键索引

主键有两个功能：加速查询 和 唯一约束（不可含null）

 1 创建表+创建主键
 2 create table in1(
 3     nid int not null auto_increment primary key,
 4     name varchar(32) not null,
 5     email varchar(64) not null,
 6     extra text,
 7     index ix_name (name)
 8 )
 9 OR
10 create table in1(
11     nid int not null auto_increment,
12     name varchar(32) not null,
13     email varchar(64) not null,
14     extra text,
15     primary key(ni1),
16     index ix_name (name)
17 )
18 创建：alter table 表名 add primary key(列名);
19 删除：alter table 表名 drop primary key;
20       alter table 表名  modify  列名 int, drop primary key;

操作

4、组合索引

组合索引是将n个列组合成一个索引

create table in3(
    nid int not null auto_increment primary key,
    name varchar(32) not null,
    email varchar(64) not null,
    extra text
)
创建组合索引：create index ix_name_email on in3(name,email);
注意：对于同时搜索n个条件时，组合索引的性能好于多个单一索引合并。

操作

5、显示索引信息

SHOW INDEX FROM table_name\G；

八、pyMySQL

pymysql基本操作

（使用原生sql语句）

 1 import pymysql
 2 # 创建连接
 3 conn = pymysql.connect(host=‘192.168.43.165‘, port=3306, user=‘root‘, passwd=‘123456‘, db=‘zzdb‘)
 4 # 创建游标
 5 cursor = conn.cursor()
 6 #查询
 7 # effect_row = cursor.execute("select * from student")
 8 # #输出查询结果
 9 # print(cursor.fetchone())
10 # print(cursor.fetchall())
11 # 执行SQL，单行插入
12 effect_row = cursor.execute("insert into student(name,age,register_date) values(‘z1‘,33,‘2017-2-3‘)")
13 # 执行SQL，多行插入
14 # data = [
15 #     ("a1",13,"2018-2-3"),
16 #     ("a2",31,"2018-3-3"),
17 #     ("a3",41,"2018-4-3"),
18 # ]
19 # cursor.executemany("insert into student(name,age,register_date) value(%s,%s,%s)",data)
20 # 提交，不然无法保存新建或者修改的数据
21 conn.commit()
22 # 关闭游标
23 cursor.close()
24 # 关闭连接
25 conn.close()

pymysql

九、sqlalchemy ORM

1、orm介绍

object relational mapping,就是对象映射关系程序，简单来说我们类似python这种面向对象的程序来说一切皆对象，但是我们使用的数据库却都是关系型的，为了保证一致的使用习惯，通过orm将编程语言的对象模型和数据库的关系模型建立映射关系，这样我们在使用编程语言对数据库进行操作的时候可以直接使用编程语言的对象模型进行操作就可以了，而不用直接使用sql语言。

优点：

a、隐藏了数据访问细节，“封闭”的通用数据库交互，使得我们的通用数据库交互变得简单易行，并且完全不用考虑该死的SQL语句。

b、ORM使我们构造固化数据结构变得简单易行。

缺点：

无可避免的，自动化意味着映射和关联管理，代价是牺牲性能。现在的各种ORM框架都在尝试使用各种方法来减轻这块（LazyLoad，Cache），效果还是很显著的。

2、sqlalchemy基本使用

  1 import sqlalchemy
  2 from sqlalchemy import create_engine
  3 from sqlalchemy.ext.declarative import declarative_base
  4 from sqlalchemy import Column, Integer, String,UniqueConstraint,Index
  5 from sqlalchemy.orm import sessionmaker
  6
  7 engine = create_engine("mysql+pymysql://root:[email protected]/zzdb",
  8                                     encoding=‘utf-8‘)
  9 Base = declarative_base() #生成orm基类
 10 #创建表单
 11 class User(Base):
 12     __tablename__ = ‘user‘ #表名
 13     id = Column(Integer, primary_key=True)
 14     name = Column(String(32))
 15     password = Column(String(64))
 16
 17     __table_args__ = (   #表配置
 18         UniqueConstraint(‘id‘, ‘name‘, name=‘uix_id_name‘),  #唯一约束
 19         Index(‘ix_id_name‘, ‘name‘, ‘password‘),   #创建组合索引
 20     )
 21     def __repr__(self):
 22         return "<%s name:%s>"%(self.id,self.name)     #添加这个函数后可以清楚的现实返回的内容
 23
 24 Base.metadata.create_all(engine) #创建表结构
 25
 26 #插入数据
 27 Session_class = sessionmaker(bind=engine) #创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例
 28 Session = Session_class() #生成session实例，类似cursor
 29
 30 user_obj = User(name="jj",password="000000") #生成你要创建的数据对象
 31 user_obj2 = User(name="aa",password="111111")
 32 print(user_obj.name,user_obj.id)  #此时还没创建对象呢，不信你打印一下id发现还是None
 33
 34 Session.add(user_obj) #把要创建的数据对象添加到这个session里， 一会统一创建
 35 Session.add(user_obj2)
 36 print(user_obj.name,user_obj.id) #此时也依然还没创建
 37
 38 Session.commit() #现此才统一提交，创建数据
 39
 40 #删除
 41 Session.query(User).filter(User.id > 2).delete()
 42 Session.commit()
 43
 44 #修改
 45 data = Session.query(User).filter(User.id > 1).filter(User.id < 4).first()
 46 print(data)
 47 data.name = "zab"
 48 data.password = "444444"
 49
 50 Session.query(User).filter(User.id > 2).update({"name" : "099"})
 51 Session.query(User).filter(User.id > 2).update({User.name: User.name + "099"}, synchronize_session=False)
 52 Session.query(User).filter(User.id > 2).update({"num": User.num + 1}, synchronize_session="evaluate")
 53 Session.commit()
 54
 55 #查询
 56 data = Session.query(User).filter_by(name = "zz").all()  #查询指定
 57 data = Session.query(User).filter(id > 2).all()  #指定判断类条件
 58
 59 data = Session.query(User).filter_by().all()    #查询所有
 60 print(data)
 61 print(data[0].name,data[0].password)
 62
 63 #多条件查询
 64 data = Session.query(User).filter(User.id > 1).filter(User.id < 4).all()
 65 print(data)
 66
 67 #其他查询
 68 ‘‘‘
 69 #　条件
 70 ret = Session.query(User).filter_by(name=‘zz‘).all()
 71 ret = Session.query(User).filter(User.id > 1, User.name == ‘aa‘).all()
 72 ret = Session.query(User).filter(User.id.between(1, 3), User.name == ‘aa‘).all()
 73 ret = Session.query(User).filter(User.id.in_([1,3,4])).all()
 74 ret = Session.query(User).filter(~User.id.in_([1,3,4])).all()
 75 ret = Session.query(User).filter(User.id.in_(Session.query(User.id).filter_by(name=‘zz‘))).all()
 76 from sqlalchemy import and_, or_
 77 ret = Session.query(User).filter(and_(User.id > 3, User.name == ‘aa‘)).all()
 78 ret = Session.query(User).filter(or_(User.id < 2, User.name == ‘aa‘)).all()
 79 ret = Session.query(User).filter(
 80     or_(
 81         User.id < 2,
 82         and_(User.name == ‘eric‘, User.id > 3),
 83         User.extra != ""
 84     )).all()
 85
 86 # 通配符
 87 ret = Session.query(User).filter(User.name.like(‘e%‘)).all()
 88 ret = Session.query(User).filter(~User.name.like(‘e%‘)).all()
 89
 90 # 限制
 91 ret = Session.query(User)[1:2]
 92
 93 # 排序
 94 ret = Session.query(User).order_by(User.name.desc()).all()
 95 ret = Session.query(User).order_by(User.name.desc(), User.id.asc()).all()
 96
 97 # 分组
 98 from sqlalchemy.sql import func
 99
100 ret = Session.query(User).group_by(User.extra).all()
101 ret = Session.query(
102     func.max(User.id),
103     func.sum(User.id),
104     func.min(User.id)).group_by(User.name).all()
105
106 ret = Session.query(
107     func.max(User.id),
108     func.sum(User.id),
109     func.min(User.id)).group_by(User.name).having(func.min(User.id) >2).all()
110
111 # 连表
112 ret = Session.query(User, Favor).filter(User.id == Favor.nid).all()
113 ret = Session.query(Person).join(Favor).all()
114 ret = Session.query(Person).join(Favor, isouter=True).all()
115
116 # 组合
117 q1 = Session.query(User.name).filter(User.id > 2)
118 q2 = Session.query(Favor.caption).filter(Favor.nid < 2)
119 ret = q1.union(q2).all()
120
121 q1 = Session.query(User.name).filter(User.id > 2)
122 q2 = Session.query(Favor.caption).filter(Favor.nid < 2)
123 ret = q1.union_all(q2).all()
124 ‘‘‘
125
126 # 回滚
127 fake_user = User(name = ‘bool‘,password = ‘123‘)
128 Session.add(fake_user)
129 print(Session.query(User).filter(User.name.in_([‘bool‘,])).all())
130 Session.rollback()
131 print(Session.query(User).filter(User.name.in_([‘bool‘,])).all())
132
133 #统计
134 print(Session.query(User).filter(User.name.in_([‘aa‘,‘bb‘])).count())   #count()
135
136 #分组统计
137 from sqlalchemy import func
138 print(Session.query(User.name,func.count(User.name)).group_by(User.name).all())

增删改查

3、外键关联

 1 import sqlalchemy
 2 from sqlalchemy import create_engine
 3 from sqlalchemy.ext.declarative import declarative_base
 4 from sqlalchemy import Column, Integer, String,ForeignKey
 5 from sqlalchemy.orm import sessionmaker,relationship
 6
 7 engine = create_engine("mysql+pymysql://root:[email protected]/zzdb",
 8                                     encoding=‘utf-8‘)
 9 Base = declarative_base() #生成orm基类
10
11 class Student(Base):
12     __tablename__ = ‘student‘ #表名
13     id = Column(Integer, primary_key=True)
14     name = Column(String(32),nullable=False)
15     register_date = Column(String(32),nullable=False)
16
17     def __repr__(self):
18         return "<%s name:%s>"%(self.id,self.name)
19
20 class StudyRecord(Base):
21     __tablename__ = ‘study_record‘ #表名
22     id = Column(Integer, primary_key=True)
23     day = Column(Integer,nullable=False)
24     status  = Column(String(32),nullable=False)
25     stu_id = Column(Integer,ForeignKey("student.id"))
26
27     student = relationship("Student", backref="my_study_record") #这个nb，允许你在user表里通过backref字段反向查出所有它在addresses表里的关联项
28     def __repr__(self):
29         return "<%s day:%s status:%s>"%(self.student.name,self.day,self.status)
30
31 # Base.metadata.create_all(engine) #创建表结构
32
33 Session_class = sessionmaker(bind=engine) #创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例
34 Session = Session_class() #生成session实例，类似cursor
35 #
36 # s1 = Student(name="zz",register_date = "2018-4-12")
37 # s2 = Student(name="aa",register_date = "2018-1-12")
38 # s3 = Student(name="bb",register_date = "2018-3-12")
39 # s4 = Student(name="cc",register_date = "2018-2-12")
40 #
41 # study_obj1 = StudyRecord(day = 1,status = "yes",stu_id = 1)
42 # study_obj2 = StudyRecord(day = 2,status = "yes",stu_id = 1)
43 # study_obj3 = StudyRecord(day = 3,status = "yes",stu_id = 1)
44 # study_obj4 = StudyRecord(day = 1,status = "yes",stu_id = 2)
45 #
46 # Session.add_all([s1,s2,s3,s4,study_obj1,study_obj2,study_obj3,study_obj4])
47
48 stu_obj = Session.query(Student).filter(Student.name == "zz").first()
49
50 print(stu_obj.my_study_record)
51
52 Session.commit()

外键关联

4、多外键关联

 1 from sqlalchemy import Integer, ForeignKey, String, Column
 2 from sqlalchemy.ext.declarative import declarative_base
 3 from sqlalchemy.orm import relationship
 4 from sqlalchemy import create_engine
 5
 6 engine = create_engine("mysql+pymysql://root:[email protected]/zzdb",
 7                                     encoding=‘utf-8‘)
 8
 9 Base = declarative_base()
10
11 class Customer(Base):
12     __tablename__ = ‘customer‘
13     id = Column(Integer, primary_key=True)
14     name = Column(String(64))
15
16     billing_address_id = Column(Integer, ForeignKey("address.id"))
17     shipping_address_id = Column(Integer, ForeignKey("address.id"))
18
19     billing_address = relationship("Address", foreign_keys=[billing_address_id])
20     shipping_address = relationship("Address",foreign_keys=[shipping_address_id])
21
22 class Address(Base):
23     __tablename__ = ‘address‘
24     id = Column(Integer, primary_key=True)
25     street = Column(String(64))
26     city = Column(String(64))
27     state = Column(String(64))
28     def __repr__(self):
29         return self.street
30
31
32 # Base.metadata.create_all(engine) #创建表结构

一对多（表结构）

 1 from zz_rpc import  orm_fk
 2 from sqlalchemy.orm import sessionmaker
 3
 4 Session_class = sessionmaker(bind=orm_fk.engine) #创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例
 5 Session = Session_class() #生成session实例，类似cursor
 6
 7 # addr1 = orm_fk.Address(street = "Tiantongyuan",city = "ChagnPing",state = "beijing")
 8 # addr2 = orm_fk.Address(street = "Wudaokou",city = "Haidian",state = "beijing")
 9 # addr3 = orm_fk.Address(street = "Yanjiao",city = "Langfang",state = "beijing")
10 #
11 # Session.add_all([addr1,addr2,addr3])
12 # c1 = orm_fk.Customer(name = "zz",billing_address = addr1,shipping_address = addr2)
13 # c2 = orm_fk.Customer(name = "aa",billing_address = addr3,shipping_address = addr3)
14 #
15 # Session.add_all([c1,c2])
16 obj = Session.query(orm_fk.Customer).filter(orm_fk.Customer.name == "zz").first()
17 print(obj.name,obj.billing_address,obj.shipping_address)
18 Session.commit()

一对多（添加查询）

例：多对多

现在来设计一个能描述“图书”与“作者”的关系的表结构，需求是：

一本书可以有好几个作者一起出版；一个作者可以写好几本书

 1 #一本书可以有多个作者，一个作者又可以出版多本书
 2 from sqlalchemy import Table, Column, Integer,String,DATE,ForeignKey
 3 from sqlalchemy.orm import relationship
 4 from sqlalchemy.ext.declarative import declarative_base
 5 from sqlalchemy import create_engine
 6 from sqlalchemy.orm import sessionmaker
 7 Base = declarative_base()
 8 book_m2m_author = Table(‘book_m2m_author‘, Base.metadata,
 9                         Column(‘book_id‘,Integer,ForeignKey(‘books.id‘)),
10                         Column(‘author_id‘,Integer,ForeignKey(‘authors.id‘)))
11 class Book(Base):
12     __tablename__ = ‘books‘
13     id = Column(Integer,primary_key=True)
14     name = Column(String(64))
15     pub_date = Column(DATE)
16     authors = relationship(‘Author‘,secondary=book_m2m_author,backref=‘books‘)
17     def __repr__(self):
18         return self.name
19 class Author(Base):
20     __tablename__ = ‘authors‘
21     id = Column(Integer, primary_key=True)
22     name = Column(String(32))
23     def __repr__(self):
24         return self.name
25 # engine = create_engine("mysql+pymysql://root:[email protected]/zzdb",
26 #                                     encoding=‘utf-8‘)   #插入中文
27 #sqlalchemy设置编码字符集一定要在数据库访问的URL上增加charset=utf8，否则数据库的连接就不是utf8的编码格式（如果上面那个不行就用下面这个）
28 engine = create_engine("mysql+pymysql://root:[email protected]/zzdb?charset=utf8")
29 Base.metadata.create_all(engine) #创建表结构

创建表结构

from mysql_study import m2m
from sqlalchemy.orm import sessionmaker

Session_class = sessionmaker(bind=m2m.engine) #创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例
session = Session_class() #生成session实例，类似cursor
b1 = m2m.Book(name = "learn python",pub_date = "2018-01-04")
b2 = m2m.Book(name = "learn linux",pub_date = "2018-04-12")
b3 = m2m.Book(name = "learn oracle",pub_date = "2018-05-08")
b4 = m2m.Book(name = "学中文",pub_date = "2018-05-08")
a1 = m2m.Author(name = "zz")
a2 = m2m.Author(name = "jj")
a3 = m2m.Author(name = "yy")
b1.authors = [a1,a3]
b2.authors = [a2,a3]
b3.authors = [a1,a2,a3]
session.add_all([b1,b2,b3,a1,a2,a3])
session.add_all([b4,])

author_obj = session.query(m2m.Author).filter(m2m.Author.name == "zz").first()
print(author_obj.books)
print(author_obj.books[1].pub_date)
book_obj = session.query(m2m.Book).filter(m2m.Book.id == 3).first()
print(book_obj.authors)
session.commit()

创建内容查询

多对多删除

删除数据时不用管book_m2m_authors，sqlalchemy会自动帮你把对应的数据删除

通过书删除作者时只会把这本书对应的该作者删除，而删除作者时，会把这个作者跟所有书的关联关系数据也自动删除

原文地址：https://www.cnblogs.com/hy0822/p/9299646.html