python教程18、python操作Mysql,pymysql,SQLAchemy

一、MySQL

1、概述

什么是数据库 ？
　答：数据的仓库，和Excel表中的行和列是差不多的，只是有各种约束和不同数据类型的表格

什么是 MySQL、Oracle、SQLite、Access、MS SQL Server等 ？
　答：他们均是一个软件，都有两个主要的功能：

  • a. 将数据保存到文件或内存
  • b. 接收特定的命令，然后对文件进行相应的操作

    PS：如果有了以上软件，无须自己再去创建文件和文件夹，而是直接传递 命令 给上述软件，让其来进行文件操作，他们统称为数据库管理系统（DBMS，Database Management System）

什么是SQL ？
　答：上述提到MySQL等软件可以接受命令，并做出相应的操作，由于命令中可以包含删除文件、获取文件内容等众多操作，对于编写的命令就是是SQL语句。SQL语句是结构化语言（Structured Query Language）的缩写，SQL是一种专门用来与数据库通信的语言。

2、下载安装

MySQL是一个关系型数据库管理系统，由瑞典MySQL AB 公司开发，目前属于 Oracle 旗下公司。MySQL 最流行的关系型数据库管理系统，在 WEB 应用方面MySQL是最好的 RDBMS (Relational Database Management System，关系数据库管理系统) 应用软件之一。

想要使用MySQL来存储并操作数据，则需要做几件事情：
　　a. 安装MySQL服务端
　　b. 安装MySQL客户端
　　b. 【客户端】连接【服务端】
　　c. 【客户端】发送命令给【服务端MySQL】服务的接受命令并执行相应操作(增删改查等)


1

2

3

4

5

6

7

8

9

下载

        http://dev.mysql.com/downloads/mysql/

安装

        windows:

            点点点

        Linux:

            yum install mysql-server

        Mac:

            点点点

3、数据库操作

(1)、显示数据


1

SHOW DATABASES;

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

(2)、使用数据库


1

USE db_name;

(3)、显示所有表


1

SHOW TABLES;

(4)、用户授权

用户管理：


1

2

3

4

5

6

7

8

9

10

创建用户

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

删除用户

    drop user ‘用户名‘@‘IP地址‘;

修改用户

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

修改密码

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

 

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

授权管理：


1

2

3

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

grant  权限 on 数据库.表 to   ‘用户‘@‘IP地址‘ identified by ‘密码‘     -- 授权并创建密码

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

-->有哪些权限：

 

-->数据库范围：

对于目标数据库以及内部其他：
    数据库名.*           数据库中的所有
    数据库名.表          指定数据库中的某张表
    数据库名.存储过程     指定数据库中的存储过程
    *.*                所有数据库

-->用户范围：

用户名@IP地址         用户只能在改IP下才能访问
用户名@192.168.1.%   用户只能在改IP段下才能访问(通配符%表示任意)
用户名@%             用户可以再任意IP下访问(默认IP地址为%)

4、表操作

(1)、创建表


1

2

3

4

create table 表名(

    列名  类型  是否可以为空，

    列名  类型  是否可以为空

)

约束(1)是否可空null

是否可空，null表示空，非字符串
    not null    - 不可空
    null        - 可空

约束(2)默认值default

默认值，创建列时可以指定默认值，当插入数据时如果未主动设置，则自动添加默认值
    create table tb1(
        nid int not null defalut 2,
        num int not null
    )

约束(3)自增auto_increment

自增，如果为某列设置自增列，插入数据时无需设置此列，默认将自增（表中只能有一个自增列）
    create table tb1(
        nid int not null auto_increment primary key,
        num int null
    )
    或
    create table tb1(
        nid int not null auto_increment,
        num int null,
        index(nid)
    )
    注意：1、对于自增列，必须是索引（含主键）。
         2、对于自增可以设置步长和起始值
             show session variables like ‘auto_inc%‘;
             set session auto_increment_increment=2;
             set session auto_increment_offset=10;

             shwo global  variables like ‘auto_inc%‘;
             set global auto_increment_increment=2;
             set global auto_increment_offset=10;

约束(4)主键primary key

主键，一种特殊的唯一索引，不允许有空值，如果主键使用单个列，则它的值必须唯一，如果是多列，则其组合必须唯一。
    create table tb1(
        nid int not null auto_increment primary key,
        num int null
    )
    或
    create table tb1(
        nid int not null,
        num int not null,
        primary key(nid,num)
    )

约束(5)唯一键unique key

    create table tb1(
        nid int not null auto_increment primary key,
        num int null unique key,
    )

约束(6)外键foreign key

外键，一个特殊的索引，只能是指定内容
    creat table color(
        nid int not null primary key,
        name char(16) not null
    )

    create table fruit(
        nid int not null primary key,
        smt char(32) null ,
        color_id int not null,
        constraint fk_cc foreign key (color_id) references color(nid)
    )

(2)、删除表


1

drop table 表名

(3)、清空表


1

2

delete from 表名

truncate table 表名  # 和上面的区别在于，这条语句能够使自增id恢复到0

(4)、修改表


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

添加列：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的数据类型大致分为：数值、时间和字符串

http://www.runoob.com/mysql/mysql-data-types.html

五、基本操作

1、增加数据

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

2、删除数据

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

3、修改数据

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

4、查询数据

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

5、其他

 

一些总结和练习

六、视图

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

 临时表搜索

1、创建视图

 

2、删除视图

 

3、修改视图

 

4、使用视图

使用视图时，将其当作表进行操作即可，由于视图是虚拟表，所以无法使用其对真实表进行创建、更新和删除操作，仅能做查询用。

 

七、触发器

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

1、创建基本语法

 

 插入前触发器

 插入后触发器

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

2、删除触发器

DROP TRIGGER tri_after_insert_tb1;

3、使用触发器

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

insert into tb1(num) values(666)

八、存储过程

存储过程是一个SQL语句集合，当主动去调用存储过程时，其中内部的SQL语句会按照逻辑执行。

1、创建存储过程和执行过程

 

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

  • in          仅用于传入参数用
  • 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执行存储过程

九、函数

MySQL中提供了许多内置函数，例如：

 部分内置函数

更多：

http://doc.mysql.cn/mysql5/refman-5.1-zh.html-chapter/functions.html#encryption-functions

http://dev.mysql.com/doc/refman/5.7/en/string-functions.html

1、自定义函数

 

2、删除函数

drop function func_name;

3、执行函数

 

十、索引

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

 支持事务的存储过程

 执行存储过程

十一、索引

索引，是数据库中专门用于帮助用户快速查询数据的一种数据结构。类似于字典中的目录，查找字典内容时可以根据目录查找到数据的存放位置，然后直接获取即可。

MySQL中常见索引有：

  • 普通索引
  • 唯一索引
  • 主键索引
  • 组合索引

1、普通索引

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

 创建表+索引

 创建索引

 删除索引

 查看索引

注意：对于创建索引时如果是BLOB 和 TEXT 类型，必须指定length。

 

2、唯一索引

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

 创建表+索引

 创建唯一键索引

 删除唯一键索引

3、主键索引

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

 创建表+主键索引

 创建主键

 删除主键

4、组合索引

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

其应用场景为：频繁的同时使用n列来进行查询，如：where n1 = ‘redhat‘ and n2 = 666。

 创建表

 创建组合索引

如上创建组合索引之后，查询：

  • name and email  -- 使用索引
  • name                 -- 使用索引
  • email                 -- 不使用索引

注意：对于同时搜索n个条件时，组合索引的性能好于多个单一索引合并。

其他

1、条件语句

 

2、循环语句

 while循环

 repeat循环

 loop循环

3、动态执行SQL语句

 

二、pymsql模块

pymsql是Python中操作MySQL的模块，其使用方法和MySQLdb几乎相同。这里介绍pymysql

一、下载安装：


1

pip install pymysql

二、使用

# 先往数据库插入点数据
mysql> CREATE DATABASE IF NOT EXISTS testdb DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;

mysql> use testdb;

mysql> CREATE TABLE hosts (id int not null auto_increment primary key,ip varchar(20) not null,port int not null);

mysql> INSERT INTO hosts (ip,port) values
       (‘1.1.1.1‘,22),(‘1.1.1.2‘,22),
       (‘1.1.1.3‘,22),(‘1.1.1.4‘,22),
       (‘1.1.1.5‘,22);

1、执行SQL


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import pymysql

# 创建连接

conn = pymysql.connect(host=‘127.0.0.1‘, port=3306, user=‘root‘, passwd=‘123456‘, db=‘testdb‘, charset=‘utf8‘)

# 创建游标

cursor = conn.cursor()

# 执行SQL，并返回收影响行数

r = effect_row = cursor.execute("update hosts set ip = ‘1.1.1.2‘")

print(r)

# 执行SQL，并返回受影响行数

effect_row = cursor.execute("update hosts set ip = ‘1.1.1.6‘ where id > %s", (6,))

# 执行SQL，并返回受影响行数

effect_row = cursor.executemany("insert into hosts(ip,port) values(%s,%s)", [("1.1.1.7",21),("1.1.1.8",23)])

# 提交，不然无法保存新建或者修改的数据

conn.commit()

# 关闭游标

cursor.close()

# 关闭连接

conn.close()

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


1

2

3

4

5

6

7

8

9

10

11

12

13

14

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import pymysql

conn = pymysql.connect(host=‘127.0.0.1‘, port=3306, user=‘root‘, passwd=‘123456‘, db=‘testdb‘)

cursor = conn.cursor()

cursor.executemany("insert into hosts(ip,port) values(%s,%s)", [("1.1.1.9",21),("1.1.1.10",222)])

conn.commit()

cursor.close()

conn.close()

# 获取最新自增ID

new_id = cursor.lastrowid

print(new_id)<br><br># 获取当前行行号<br>current_row = cursor.rownumber<br>print(current_row)

3、获取查询数据


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import pymysql

conn = pymysql.connect(host=‘127.0.0.1‘, port=3306, user=‘root‘, passwd=‘123456‘, db=‘testdb‘)

cursor = conn.cursor()

cursor.execute("select * from hosts")

# 获取第一行数据

row = cursor.fetchone()

print(row)

print(cursor.rownumber)

# 获取第二行数据

row_1 = cursor.fetchone()

print(row_1)

print(cursor.rownumber)

# 获取前n行数据

row_2 = cursor.fetchmany(3)

print(row_2)

# 获取所有数据

row_3 = cursor.fetchall()

print(row_3)

conn.commit()

cursor.close()

conn.close()

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

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

4、fetch数据类型

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


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import pymysql

conn = pymysql.connect(host=‘127.0.0.1‘, port=3306, user=‘root‘, passwd=‘123456‘, db=‘testdb‘)

# 游标设置为字典类型

cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)

r = cursor.execute("select * from hosts")

print(r)

result = cursor.fetchone()

print(result)

conn.commit()

cursor.close()

conn.close()

三、SQLAchemy

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

SQLAlchemy安装


1

pip install sqlalchemy

SQLAlchemy本身无法操作数据库，其必须以来pymsql等第三方插件，Dialect用于和数据API进行交流，根据配置文件的不同调用不同的数据库API，从而实现对数据库的操作，如：


1

2

3

4

5

6

7

8

9

10

11

12

13

MySQL-Python

    mysql+mysqldb://<user>:<password>@<host>[:<port>]/<dbname>

  

pymysql

    mysql+pymysql://<username>:<password>@<host>/<dbname>[?<options>]

  

MySQL-Connector

    mysql+mysqlconnector://<user>:<password>@<host>[:<port>]/<dbname>

  

cx_Oracle

    oracle+cx_oracle://user:pass@host:port/dbname[?key=value&key=value...]

  

更多详见：http://docs.sqlalchemy.org/en/latest/dialects/index.html

一、底层处理

使用 Engine/ConnectionPooling/Dialect 进行数据库操作，Engine使用ConnectionPooling连接数据库，然后再通过Dialect执行SQL语句。


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

#!/usr/bin/env python

# -*- coding:utf-8 -*-

from sqlalchemy import create_engine

engine = create_engine("mysql+pymysql://root:[email protected]:3306/testdb", max_overflow=5)  # max_overflow可以超出连接池5个连接

#执行SQL

cur = engine.execute(

    "INSERT INTO hosts (ip,port) VALUES (‘1.1.1.11‘, 22)"

)

#新插入行自增ID

cur.lastrowid

#执行SQL

cur = engine.execute(

    "INSERT INTO hosts (ip,port) VALUES(%s, %s)",[(‘1.1.1.12‘, 22),(‘1.1.1.13‘, 55),]

)

#执行SQL

cur = engine.execute(

    "INSERT INTO hosts (ip,port) VALUES (%(ip)s, %(port)s)",

    ip=‘1.1.1.15‘, port=80

)

#执行SQL

cur = engine.execute(‘select * from hosts‘)

#获取第一行数据

cur.fetchone()

#获取第n行数据

cur.fetchmany(3)

#获取所有数据

cur.fetchall()

二、ORM功能使用

使用 ORM/Schema Type/SQL Expression Language/Engine/ConnectionPooling/Dialect 所有组件对数据进行操作。根据类创建对象，对象转换成SQL，执行SQL。

1、创建表


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

#!/usr/bin/env python

# -*- coding:utf-8 -*-

from sqlalchemy.ext.declarative import declarative_base

from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index

from sqlalchemy.orm import sessionmaker, relationship

from sqlalchemy import create_engine

engine = create_engine("mysql+pymysql://root:[email protected]:3306/testdb", max_overflow=5)

Base = declarative_base()

# 创建单表

class Users(Base):

    __tablename__ = ‘users‘

    id = Column(Integer, primary_key=True,autoincrement=True)

    name = Column(String(32))

    extra = Column(String(16))

    __table_args__ = (

    UniqueConstraint(‘id‘, ‘name‘, name=‘uix_id_name‘), # 设置组合唯一键约束

        Index(‘ix_id_name‘, ‘name‘, ‘extra‘),     # 创建索引

    )

# 一对多关系

class Favor(Base):

    __tablename__ = ‘favor‘

    nid = Column(Integer, primary_key=True,autoincrement=True)

    caption = Column(String(50), default=‘playing‘, unique=True)

class Person(Base):

    __tablename__ = ‘person‘

    nid = Column(Integer, primary_key=True,autoincrement=True)

    name = Column(String(32), index=True, nullable=True)

    favor_id = Column(Integer, ForeignKey("favor.nid"))  # 设置外键,外键依赖于主表favor的主键nid

    # 与生成表结构无关，仅用于外键查询方便

    favor = relationship("Favor", backref=‘pers‘)

# 多对多

class Group(Base):

    __tablename__ = ‘group‘

    id = Column(Integer, primary_key=True,autoincrement=True)

    name = Column(String(64), unique=True, nullable=False)

    # group = relationship(‘Group‘,secondary=ServerToGroup,backref=‘host_list‘)

class Server(Base):

    __tablename__ = ‘server‘

    id = Column(Integer, primary_key=True, autoincrement=True)

    hostname = Column(String(64), unique=True, nullable=False)

    port = Column(Integer, default=22)

class ServerToGroup(Base):

    """多对多关系,则是多生成一张表用来存储主键"""

    __tablename__ = ‘servertogroup‘

    nid = Column(Integer, primary_key=True, autoincrement=True)

    server_id = Column(Integer, ForeignKey(‘server.id‘))  # 设置主键

    group_id = Column(Integer, ForeignKey(‘group.id‘))    # 设置主键

def init_db():

    """创建表的函数,调用之后会创建表"""

    Base.metadata.create_all(engine)

def drop_db():

    """删除表的函数,调用之后会删除表"""

    Base.metadata.drop_all(engine)

init_db() # 创建完最好注释,如果表已经创建,执行此步不会再创建表

# drop_db()

# 想要对表进行操作则需要绑定会话

Session = sessionmaker(bind=engine)

session = Session()

2、操作表　　

(1)增加数据


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

# 插入一条

obj = Users(name=‘redhat‘, extra=‘rh‘)

print(obj)

session.add(obj)

# 插入多条

session.add_all([

    Users(name=‘centos‘, extra=‘ct‘),

    Users(name=‘debian‘, extra=‘db‘),

    Users(name=‘ubuntu‘, extra=‘ub‘),

    Users(name=‘fedora‘, extra=‘fd‘),

])

# 插入完需要提交否则不生效

session.commit()

(2)删除数据　　


1

2

session.query(Users).filter(Users.id > 5).delete()

session.commit()

(3)修改数据


1

2

3

4

session.query(Users).filter(Users.id > 2).update({"name" : "opensuse"})

session.query(Users).filter(Users.id > 2).update({Users.name: Users.name + "099"}, synchronize_session=False)

#session.query(Users).filter(Users.id > 2).update({"num": Users.num + 1}, synchronize_session="evaluate")

session.commit()

(4)查询数据(如果没有使用ORM则返回的是一个表对象)


1

2

3

4

ret = session.query(Users).all()

ret = session.query(Users.name, Users.extra).all()

ret = session.query(Users).filter_by(name=‘opensuse099‘).all()

ret = session.query(Users).filter_by(name=‘opensuse099‘).first()

(5)其他一些查询操作


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

#　条件

ret = session.query(Users).filter_by(name=‘centos‘).all()

ret = session.query(Users).filter(Users.id > 1, Users.name == ‘centos‘).all()

ret = session.query(Users).filter(Users.id.between(1, 3), Users.name == ‘centos‘).all()

ret = session.query(Users).filter(Users.id.in_([1,3,4])).all()

ret = session.query(Users).filter(~Users.id.in_([1,3,4])).all()

ret = session.query(Users).filter(Users.id.in_(session.query(Users.id).filter_by(name=‘centos‘))).all()

from sqlalchemy import and_, or_

ret = session.query(Users).filter(and_(Users.id > 3, Users.name == ‘centos‘)).all()

ret = session.query(Users).filter(or_(Users.id < 2, Users.name == ‘centos‘)).all()

ret = session.query(Users).filter(

    or_(

        Users.id < 2,

        and_(Users.name == ‘centos‘, Users.id > 3),

        Users.extra != ""

    )).all()

# 通配符

ret = session.query(Users).filter(Users.name.like(‘e%‘)).all()

ret = session.query(Users).filter(~Users.name.like(‘e%‘)).all()

# 限制

ret = session.query(Users)[1:2]

# 排序

ret = session.query(Users).order_by(Users.name.desc()).all()

ret = session.query(Users).order_by(Users.name.desc(), Users.id.asc()).all()

# 分组

from sqlalchemy.sql import func

ret = session.query(Users).group_by(Users.extra).all()

ret = session.query(

    func.max(Users.id),

    func.sum(Users.id),

    func.min(Users.id)).group_by(Users.name).all()

ret = session.query(

    func.max(Users.id),

    func.sum(Users.id),

    func.min(Users.id)).group_by(Users.name).having(func.min(Users.id) >2).all()

# 连表

ret = session.query(Users, Favor).filter(Users.id == Favor.nid).all()

ret = session.query(Person).join(Favor).all()

ret = session.query(Person).join(Favor, isouter=True).all()

# 组合

q1 = session.query(Users.name).filter(Users.id > 2)

q2 = session.query(Favor.caption).filter(Favor.nid < 2)

ret = q1.union(q2).all()

q1 = session.query(Users.name).filter(Users.id > 2)

q2 = session.query(Favor.caption).filter(Favor.nid < 2)

ret = q1.union_all(q2).all()

三、一对多、多对多的连表查询

一对多

(1)、新创建个数据库sqldb

mysql> create database sqldb default character set utf8 collate utf8_general_ci;

(2)、通过ORM生成表


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

#!/usr/bin/env python

# -*- coding:utf-8 -*-

from sqlalchemy import create_engine

from sqlalchemy.ext.declarative import declarative_base

from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index

from sqlalchemy.orm import sessionmaker, relationship

engine = create_engine("mysql+pymysql://root:[email protected]:3306/sqldb", max_overflow=5)

Base = declarative_base()

# 一对多关系

class User(Base):

    __tablename__ = ‘user‘

    nid = Column(Integer, primary_key=True,autoincrement=True)

    username = Column(String(50))

    group_id = Column(Integer, ForeignKey("group.nid"))

    # 虚拟关系与Group建立关系，相当于会User生成一个group字段，Group表生成一个uuu字段，实际是不会生成这些字段只是虚拟的关系,其实只是生成了sql语句

    group = relationship("Group", backref=‘uuu‘)

    def __repr__(self):

        """只是打印的时候输出的内容和数据库取数据没有关系"""

        temp = "%s:%s:%s" %(self.nid,self.username,self.group_id)

        return temp

class Group(Base):

    __tablename__ = ‘group‘

    nid = Column(Integer, primary_key=True,autoincrement=True)

    caption = Column(String(50))

def init_db():

    Base.metadata.create_all(engine)

def drop_db():

    Base.metadata.drop_all(engine)

init_db()

#drop_db()

Session = sessionmaker(bind=engine)

session = Session()

(3)、增加数据，执行完需要注释掉


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

session.add_all([

    Group(caption=‘chuzhong‘),

    Group(caption=‘gaozhong‘),

    Group(caption=‘daxue‘),

])

session.add_all([

    User(username=‘redhat‘, group_id=1),

    User(username=‘centos‘, group_id=2),

    User(username=‘fedora‘, group_id=3),

    User(username=‘debian‘, group_id=2),

    User(username=‘ubuntu‘, group_id=1),

    User(username=‘geentoo‘, group_id=3),

    User(username=‘archlinux‘, group_id=1),

    User(username=‘windows‘, group_id=2),

    User(username=‘suse‘, group_id=3),

])

session.commit()

(4)、内连接


1

2

3

4

5

6

# select * from user left join group on user.group_id = group.nid

sql = session.query(User,Group).join(Group)        # 打印SQL语句

print(sql)

ret = session.query(User,Group).join(Group).all()  # 默认是内连接

print(ret)

(5)、外连接


1

2

3

4

5

sql = session.query(User,Group).join(Group,isouter=True)        # 打印sql语句

print(sql)

ret = session.query(User,Group).join(Group,isouter=True).all()  # isouter=True 指定外连接,默认是做外连接

print(ret)

(6)、练习：

-->获取User表完整信息,两种方式


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

# 通过传统方式

sql = session.query(User.username,Group.caption).join(Group,isouter=True)

print(sql)

ret = session.query(User.username,Group.caption).join(Group,isouter=True).all() 

print(ret)

# 通过虚拟关系

# 一般relationship 外键设置在哪张表，relationship就设置在哪表，通过这张表查询就叫正向查询，

ret = session.query(User).all()

for obj in ret:

    # obj代指user表的每一行数据

    # obj.group代指group对象

    print(obj.nid,obj.username,obj.group_id,

          obj.group,obj.group.nid,obj.group.caption)

-->通过Group表属于daxue的有多少username,两种方式


1

2

3

4

5

6

7

8

9

10

# 传统方式

ret = session.query(User.username, Group.caption).join(Group, isouter=True).filter(Group.caption == ‘daxue‘).all()

print(ret)

# 通过虚拟关系

# 反向查询

obj = session.query(Group).filter(Group.caption == ‘daxue‘).first()

print(obj.nid)

print(obj.caption)

print(obj.uuu)

多对多　　

(1)、通过ORM生成表　　


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

#!/usr/bin/env python

# -*- coding:utf-8 -*-

from sqlalchemy import create_engine

from sqlalchemy.ext.declarative import declarative_base

from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index

from sqlalchemy.orm import sessionmaker, relationship

engine = create_engine("mysql+pymysql://root:[email protected]:3306/sqldb", max_overflow=5)

Base = declarative_base()

# 多对多关系

class Host(Base):

    __tablename__ = ‘host‘

    nid = Column(Integer, primary_key=True,autoincrement=True)

    hostname = Column(String(50))

    ip = Column(String(32))

    port = Column(String(32))

class HostUser(Base):

    __tablename__ = ‘host_user‘

    nid = Column(Integer, primary_key=True,autoincrement=True)

    username = Column(String(32))

class HostToHostUser(Base):

    __tablename__ = ‘host_to_host_user‘

    nid = Column(Integer, primary_key=True,autoincrement=True)  # 保留主键,以后通过找主键删除数据方便

    host_id = Column(Integer,ForeignKey(‘host.nid‘))

    host_user_id = Column(Integer,ForeignKey(‘host_user.nid‘))

    host = relationship(‘Host‘,backref=‘h‘)

    host_user = relationship(‘HostUser‘,backref=‘u‘)

def init_db():

    Base.metadata.create_all(engine)

def drop_db():

    Base.metadata.drop_all(engine)

init_db()

# drop_db()

Session = sessionmaker(bind=engine)

session = Session()

(2)增加数据，执行完需要注释掉


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

session.add_all([

    Host(hostname=‘c1‘,ip=‘1.1.1.1‘,port=‘22‘),

    Host(hostname=‘c2‘,ip=‘1.1.1.2‘,port=‘22‘),

    Host(hostname=‘c3‘,ip=‘1.1.1.3‘,port=‘22‘),

    Host(hostname=‘c4‘,ip=‘1.1.1.4‘,port=‘22‘),

    Host(hostname=‘c5‘,ip=‘1.1.1.5‘,port=‘22‘),

])

session.add_all([

    HostUser(username=‘root‘),

    HostUser(username=‘redhat‘),

    HostUser(username=‘centos‘),

    HostUser(username=‘ubuntu‘),

])

session.add_all([

    HostToHostUser(host_id=1,host_user_id=1),

    HostToHostUser(host_id=1,host_user_id=2),

    HostToHostUser(host_id=1,host_user_id=3),

    HostToHostUser(host_id=2,host_user_id=2),

    HostToHostUser(host_id=2,host_user_id=4),

    HostToHostUser(host_id=2,host_user_id=3),

])

session.commit()

练习：

获取Host中所有用户

第一种方式：传统方式　　


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

# 第一步获取Host中用户等于c1的对象

host_obj = session.query(Host).filter(Host.hostname == ‘c1‘).first()

# host_obj.nid 获取用户等于c1的nid

# 第二步通过HostToHostUser表找到HostUser外键对应的host_user_id

host_2_host_user = session.query(HostToHostUser.host_user_id).filter(HostToHostUser.host_id == host_obj.nid).all()

print(host_2_host_user)

[(1,),(2,),(3,)]

r = zip(*host_2_host_user)

 print(list(r)[0])

[1,2,3]

# 第三步通过第二步找到HostUser中nid对应的HostUser.username

users = session.query(HostUser.username).filter(HostUser.nid.in_(list(r)[0])).all()

print(users)

可以把上面的步骤全部合并到一起

# session.query(Host.nid).filter(Host.hostname == ‘c1‘)

# session.query(HostToHostUser.host_user_id).filter(HostToHostUser.host_id == session.query(Host.nid).filter(Host.hostname == ‘c1‘))

r = session.query(HostUser.username).filter(HostUser.nid.in_(session.query(HostToHostUser.host_user_id).filter(HostToHostUser.host_id == session.query(Host.nid).filter(Host.hostname == ‘c1‘)))).all()

print(r)

第二种方式：虚拟关系(relationship是在外键表HostToHostUser表中)


1

2

3

4

# 通过relation虚拟关系中的h字段反向查找，查找到第三表中的对象，然后通过正向查找

host_obj = session.query(Host).filter(Host.hostname == ‘c1‘).first()

for item in host_obj.h:

    print(item.host_user.username)

第三种方式：虚拟关系(relationship是在Host表中)需要修改下表结构　　


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

class HostToHostUser(Base):

    __tablename__ = ‘host_to_host_user‘

    nid = Column(Integer, primary_key=True,autoincrement=True)  # 保留主键,以后通过找主键删除数据方便

    host_id = Column(Integer,ForeignKey(‘host.nid‘))

    host_user_id = Column(Integer,ForeignKey(‘host_user.nid‘))

# 多对多关系

class Host(Base):

    __tablename__ = ‘host‘

    nid = Column(Integer, primary_key=True,autoincrement=True)

    hostname = Column(String(50))

    ip = Column(String(32))

    port = Column(String(32))

    <br>    # 关系表在User表中,realationship(A,AB.__table,B中的虚拟字段)

    host_user = relationship(‘HostUser‘,

                             secondary=HostToHostUser.__table__,

                             backref=‘h‘)

class HostUser(Base):

    __tablename__ = ‘host_user‘

    nid = Column(Integer, primary_key=True,autoincrement=True)

    username = Column(String(32))

此时直接就可以从Host表查找到HostUser表中的数据而不用涉及HostToHostUser外键表了


1

2

3

host_obj = session.query(Host).filter(Host.hostname == ‘c1‘).first()

for item in host_obj.host_user:

    print(item.username)

原文地址：https://www.cnblogs.com/stssts/p/10118116.html

时间： 2024-10-07 13:30:56

python教程18、python操作Mysql,pymysql,SQLAchemy的相关文章

好程序员Python教程分享python之变量

好程序员Python教程分享python之变量,变量(variable)是必经之路,它是学习python初始时,就会接触到的一个新的知识点,也是一个需要熟知的概念.python是一种动态类型语言,在赋值的执行中可以绑定不同类型的值,这个过程叫做变量赋值操作,赋值同时确定了变量类型. 什么是变量 在玩蛇网python学习过程中会用到许多数据,那为了方便操作,需要把这些数据分别用一个简单的名字代表,方便在接下来的程序中引用.变量就是代表某个数据(值)的名称. python变量赋值如何定义操作 变量定

mysql数据库----python操作mysql ------pymysql和SQLAchemy

本篇对于Python操作MySQL主要使用两种方式: 原生模块 pymsql ORM框架 SQLAchemy 一.pymysql pymsql是Python中操作MySQL的模块,其使用方法和MySQLdb几乎相同. 下载安装 pip3 install pymysql 使用操作 1.执行SQL 1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 import pymysql 4 5 # 创建连接 6 conn = pymysql.connect(

Python操作mysql之SQLAchemy（ORM框架）

SQLAchemy SQLAchemy 解析: SQLAchemy是python编程语言下的一款ORM框架,该框架建立在数据库API之上,使用关系对象映射进行数据库操作, 简言之便是:将对象转换成SQL,然后使用数据API执行SQL并获取执行结果. ORM框架的作用就是把数据库表的一行记录与一个对象互相做自动转换. 正确使用ORM的前提是了解关系数据库的原理. ORM就是把数据库表的行与相应的对象建立关联,互相转换. 由于关系数据库的多个表还可以用外键实现一对多.多对多等关联,相应地, ORM框

exist 存在 Python操作mysql pymysql sql注入问题 # 39

0.补充 exist 存在 了解.py 1 """""" 2 """ 3 '''exist''' 4 EXIST 关键字表示存在 5 在使用EXIST 关键字时 , 6 7 内层查询语句不返回 查询的记录, 8 而是返回一个真假值 ,True|False 9 10 当返回True时,外层语句将进行查询, 11 当返回值为False 外层查询语句不进行查询 12 13 select * from emp where e

Python学习之路-操作MYSQL

python操作mysql数据库 Python 标准数据库接口为 Python DB-API,Python DB-API为开发人员提供了数据库应用编程接口. Python 数据库接口支持非常多的数据库,你可以选择适合你项目的数据库: GadFly mSQL MySQL PostgreSQL Microsoft SQL Server 2000 Informix Interbase Oracle Sybase 你可以访问Python数据库接口及API查看详细的支持数据库列表. 不同的数据库你需要下载

Python MySQLdb模块连接操作mysql数据库实例_python

mysql是一个优秀的开源数据库,它现在的应用非常的广泛,因此很有必要简单的介绍一下用python操作mysql数据库的方法.python操作数据库需要安装一个第三方的模块,在http://mysql-python.sourceforge.net/有下载和文档. 由于python的数据库模块有专门的数据库模块的规范,所以,其实不管使用哪种数据库的方法都大同小异的,这里就给出一段示范的代码: #-*- encoding: gb2312 -*- import os, sys, string impo

python教程，python入门教程

给大家整理的这套python学习路线图,按照此教程一步步的学习来,肯定会对python有更深刻的认识.或许可以喜欢上python这个易学,精简,开源的语言.此套教程,不但有视频教程,还有源码分享,让大家能真正打开python的大门,进入这个领域.现在互联网巨头,都已经转投到人工智能领域,而人工智能最好的编程语言就是python,未来前景显而易见.黑马程序员是国内最早开设人工智能的机构. 一.首先先推荐一个教程 8天深入理解python教程:http://pan.baidu.com/s/1kVNm

【python深入5】操作mysql数据库、语言类型

1)mysql基本操作 show?databases;??//查看当前数据库 use?mysql;??//进入mysql库 show?tables;??//查看mysql库中的表 create?table?user?(name?varchar(20),password?varchar(20));??//创建user表,包含name.password字段 insert?into?user?values('Tom','1321');??//向user表里插入若干条数据 select?*?from?u

简明python教程十----python标准库

import sys def readfile(filename): 'Print a file to the standard output.' f=file(filename) while True: line=f.readline() if len(line)==0: break print line, f.close() if len(sys.argv) <2: print 'No action specified.' sys.exit() if sys.argv[1].startswi