Python实战之sqlalchemy模块 and ORM介绍

63 阅读 0 评论 42 点赞

我是靠谱客的博主务实凉面，最近开发中收集的这篇文章主要介绍Python实战之sqlalchemy模块 and ORM介绍，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

上一篇：Python实战之pymysql模块实战点击跳转
目录篇：python相关目录篇点击跳转
下一篇：前端初识(三把利器：HTML标签、CSS、JS(javascript)) 点击跳转

ORM介绍
sqlalchemy安装
实战
Linux试验通过Python的sqlalchemy模块实现mysql增删改查回滚分组统计
Linux上Python上sqlalchemy模块.连表查询试验
Linux上Python上sqlalchemy模块，创建外键（foreign key）关联表、增加数据、关联表查询试验
Python.sqlalchemy多个外键关联同一个表的ID试验（创建表和增删改查分开脚本写）
Python.sqlalchemy多对多个关系（创建表和增删改查分开脚本写）

ORM介绍

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

orm的优点：

隐藏了数据访问细节，“封闭”的通用数据库交互，ORM的核心。他使得我们的通用数据库交互变得简单易行，并且完全不用考虑该死的SQL语句。快速开发，由此而来。

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

缺点：

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

sqlalchemy安装

在Python中，最有名的ORM框架是SQLAlchemy。用户包括openstack＼Dropbox等知名公司或应用，主要用户列表http://www.sqlalchemy.org/organizations.html#openstack

Dialect用于和数据API进行交流，根据配置文件的不同调用不同的数据库API，从而实现对数据库的操作，如：

Linux、widows 安装SQLAlchemy：pip3 install SQLAlchemy

实战

Linux试验通过Python的sqlalchemy模块实现mysql增删改查回滚分组统计

（每个步骤都一一实现，但是代码就一次性上）（一般情况，创建表，和增删改查，不要写在同一个程序里面）

[root@python ~]# mysql -uroot -p123

mysql> grant all on *.* to 'python'@'%' identified by '123'; #创建一个用户名：Python、密码：123，可管理整个mysql所有的数据库，%允许所有IP和主机名：允许该主机名或者该IP使用该python用户连接

mysql> show grants for python; #查询该用户权限

mysql> show databases;

mysql> create database burgessdb charset utf8; #创建burgessdb该数据库

mysql> show databases;

vim orm_basic.py

__author__ = "Burgess Zheng"

import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column,Integer,String,MetaData,func,Date,Enum
from sqlalchemy.orm import sessionmaker,mapper
#创建表
engine = create_engine("mysql+pymysql://python:123@localhost/burgessdb?charset=utf8",
                       encoding='utf-8', echo=True)
#mysql+pymysql：我们不用写SQL语句，执行的时候调用pymysql执行
#?charset=utf8  可添加中文数据
#echo=True  等于打印整个过程

Base = declarative_base()# 生成orm基类

class User(Base): #继承Base
    __tablename__ = 'user'  # 表名
    id = Column(Integer, primary_key=True)
    name = Column(String(32))
    password = Column(String(64))

    def __repr__(self):#查询返回字段
        return "<%s name:%s>" % (self.id,self.name)

Base.metadata.create_all(engine)  # 创建表结构


#增删改查需要创建会话（光标）
#这里需要导入sessionmaker：from sqlalchemy.orm import sessionmaker（写在首）
Session_class = sessionmaker(bind=engine)  # 创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例
Session = Session_class()  # 生成session实例 #cursor

'''
创建数据
user_obj = User(name="burgess", password="burgess3714")  # 生成你要创建的数据对象
user_obj2 = User(name="jack", password="123")  # 生成你要创建的数据对象
print(user_obj.name, user_obj.id)  # 此时还没创建对象呢，不信你打印一下id发现还是None

Session.add(user_obj)  # 把要创建的数据对象添加到这个session里， 一会统一创建
Session.add(user_obj2)
print(user_obj.name, user_obj.id)  # 此时也依然还没创建

Session.commit()  # 现此才统一提交，创建数据
'''

'''
#查询
#data = Session.query(User).filter_by(name="burgess").all()
        # query():类对象  filter_by()：条件  all()符合条件所有数据
        # all,取所有数据返回列表形式
#print(data[0].name,data[0].password)
             #没有写def __repr__(self)返回方法，调用特别麻烦
                    #得到结果：
                              # burgess  burgess3714

#User类添加个返回方法def __repr__(self)
data = Session.query(User).filter_by().all()
# query():类对象  filter_by()：条件  all()符合条件所有数据
# all,取所有数据返回列表形式
# all换成first,取第一条数据
# 如果要写大于小于等于如id==2 id<2  id>2的条件
# 使用filter并且加上类User：filter(User.id>2) filter(User.id<2) filter(User.id==2)
# 使用filter_by:也可以，但是好像需要另外一种格式
#目前只做到filter_by 只可以写= ：filter_by(id=2)

print(data)
#多条件查询多个filter  格式：
           #data = Session.query(User).filter(User.id>1).filter(User.id<3).all()
'''

'''
#修改数据
data = Session.query(User).filter_by(name="jack").first()
                        #取条件name=jack的数据
print(data) #打印该数据
data.name = "Jack Liu"#修改该数据的名字
data.password = "Shit happens"#修改该数据的ID
Session.commit() #提交
#以上是单个修改
'''

'''
#回滚
fake_user = User(name="Rain",password='12345') #实例化一个数据
Session.add(fake_user)#增加数据
print(Session.query(User).filter(User.name.in_(['Jack','rain'])).all)
#打印该表name字典字符串匹配Jack rain的数据
#此刻该新增数据存在的
Session.rollback()#回滚 回滚以后该新增的Rain数据就消失了
Session.commit()

#过后如果增加数据的话，ID就间隔了1个数字(因为回滚了）
fake_user = User(name="n3",password='333') #实例化一个数据
Session.add(fake_user)#增加数据
Session.commit()
'''

#分组统计
print(Session.query(User).filter(User.name.in_(['Jack','rain'])).count)
#统计该表name字段的字符串包含Jack，rain的数据的次数
#导入func才可以分组统计： from sqlalchemy import func (写在首）

print(Session.query(User.name,func.count(User.name),).group_by(User.name).all())
#显示name字段的字符串 统计name字段字符串数据相同的次数

执行获取结果格式：[('ab', 1), ('burgess', 1), ('cd', 1), ('Jack Liu', 1), ('n3', 1)]

Linux上Python上sqlalchemy模块.连表查询试验

vim orm_multi_table_queries.py

__author__ = "Burgess Zheng"

import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column,Integer,String,MetaData,func,Date,Enum
from sqlalchemy.orm import sessionmaker,mapper

#创建表
engine = create_engine("mysql+pymysql://python:123@localhost/burgessdb?charset=utf8",
                       encoding='utf-8', echo=True)
#mysql+pymysql：我们不用写SQL语句，执行的时候调用pymysql执行
#?charset=utf8  可添加中文数据
#echo=True  等于打印整个过程

Base = declarative_base()# 生成orm基类


class User(Base): #继承Base
    __tablename__ = 'user'  # 表名
    id = Column(Integer, primary_key=True)
    name = Column(String(32))
    password = Column(String(64))

    def __repr__(self):#查询返回字段
        return "<%s name:%s>" % (self.id,self.name)

#映射数据库已经存在的表
class Student(Base): #继承Base  (之前数据库存在的表）
    __tablename__ = 'student'  # 表名
    id = Column(Integer, primary_key=True)
    name = Column(String(32),nullable=False)
    register_date = Column(DATE,nullable=False)
    gender = Column(String(32),nullable=False)

    def __repr__(self):#查询返回字段
        return "<%s name:%s>" % (self.id,self.name)

Base.metadata.create_all(engine)  # 创建表结构


#增删改查需要创建会话（光标）
#这里需要导入sessionmaker：from sqlalchemy.orm import sessionmaker（写在首）
Session_class = sessionmaker(bind=engine)  # 创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例
Session = Session_class()  # 生成session实例 #cursor

'''
#先试验往student表添加数据
s1 = Student(name="s1",register_date="2015-05-01",gender="M")
s2 = Student(name="s2",register_date="2015-03-01",gender="F")
Session.add(s1)
Session.add(s2)
Session.commit()
#linux试验正常插入
'''

#连表查询
print(Session.query(User,Student).filter(User.id==Student.id).all())
#查询user表和student表ID相同的数据

#print(Session.query(User).join(Student).all())
         # 这种方式需要两张表有外键(foreign key)
#print(Session.query(User).join(Student,isouter=True).all())
         #这种方式需要两张表有外键(foreign key)

执行获取结果格式：[(<1 name:burgess>, <1 name:xiaoming>), (<2 name:Jack Liu>, <2 name:xiaohong>)]

Linux上Python上sqlalchemy模块，创建外键（foreign key）关联表、增加数据、关联表查询试验

[root@python ~]# mysql -uroot -p123

mysql> show grants for python; #查询该用户权限

mysql> drop database burgessdb;

mysql> show databases;

mysql> create database burgessdb charset utf8; #创建burgessdb该数据库

mysql> show databases;

[root@python ~]# mkdir burgess_test
[root@python ~]# cd burgess_test/

1.创建两张表，student和study_record外键关联student表ID

[root@python burgess_test]# vim orm_foreign_key.py

__author__ = "Burgess Zheng"

import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String,DATE,Enum,ForeignKey
from sqlalchemy.orm import sessionmaker
from sqlalchemy import func

#创建表
engine = create_engine("mysql+pymysql://python:123@10.0.0.150/burgessdb?charset=utf8",
                       encoding='utf-8', echo=True)
#mysql+pymysql：我们不用写SQL语句，执行的时候调用pymysql执行
#?charset=utf8  可添加中文数据
#echo=True  等于打印整个过程

Base = declarative_base()# 生成orm基类

class Student(Base): #继承Base  (之前数据库存在的表）
    __tablename__ = 'student'  # 表名
    id = Column(Integer, primary_key=True)
    name = Column(String(32),nullable=False)
    register_date = Column(DATE,nullable=False)

    def __repr__(self):#查询返回字段
        return "<%s name:%s>" % (self.id,self.name)

class StudyRecord(Base):
    __tablename__ = 'study_record'
    id = Column(Integer,primary_key=True)
    day = Column(Integer,nullable=False)
    status = Column(String(32),nullable=False)
    stu_id = Column(Integer,ForeignKey("student.id"))#外键关联

    def __repr__(self):#查询返回字段
        return "<%s name:%s>" % (self.id,self.day)

Base.metadata.create_all(engine)  # 创建表结构

[root@python burgess_test]# py orm_foreign_key.py

[root@python ~]# mysql -uroot -p123

mysql> use burgessdb

mysql> show tables;

mysql> show create table study_recordG; #查看建表结构

2.两表增加数据

[root@python Part_twelve]# vim orm_foreign_key.py

__author__ = "Burgess Zheng"

import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String,DATE,Enum,ForeignKey
from sqlalchemy.orm import sessionmaker
from sqlalchemy import func

#创建表
engine = create_engine("mysql+pymysql://python:123@10.0.0.150/burgessdb?charset=utf8",
                       encoding='utf-8', echo=True)
#mysql+pymysql：我们不用写SQL语句，执行的时候调用pymysql执行
#?charset=utf8  可添加中文数据
#echo=True  等于打印整个过程

Base = declarative_base()# 生成orm基类

class Student(Base): #继承Base  (之前数据库存在的表）
    __tablename__ = 'student'  # 表名
    id = Column(Integer, primary_key=True)
    name = Column(String(32),nullable=False)
    register_date = Column(DATE,nullable=False)

    def __repr__(self):#查询返回字段
        return "<%s name:%s>" % (self.id,self.name)

class StudyRecord(Base):
    __tablename__ = 'study_record'
    id = Column(Integer,primary_key=True)
    day = Column(Integer,nullable=False)
    status = Column(String(32),nullable=False)
    stu_id = Column(Integer,ForeignKey("student.id"))#外键关联

    def __repr__(self):#查询返回字段
        return "<%s name:%s>" % (self.id,self.day)

Base.metadata.create_all(engine)  # 创建表结构

#增删改查需要创建会话（光标）
#这里需要导入sessionmaker：from sqlalchemy.orm import sessionmaker（写在首）
Session_class = sessionmaker(bind=engine)  # 创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例
Session = Session_class()  # 生成session实例 #cursor

#student表增加数据
s1 = Student(name="Burgess",register_date="2014-05-21")
s2 = Student(name="Jack",register_date="2014-03-21")
s3 = Student(name="Rain",register_date="2014-02-21")
s4 = Student(name="Eric",register_date="2013-01-21")

#study_record表正价数据
study_obj1 = StudyRecord(day=1,status="YES",stu_id=1)
study_obj2 = StudyRecord(day=2,status="NO",stu_id=1)
study_obj3 = StudyRecord(day=3,status="YES",stu_id=1)
study_obj4 = StudyRecord(day=1,status="YES",stu_id=2)


Session.add_all([s1,s2,s3,s4,study_obj1,study_obj2,study_obj3,study_obj4])
Session.commit()

[root@python burgess_test]# py orm_foreign_key.py

[root@python ~]# mysql -uroot -p123

mysql> use burgessdb
mysql> select * from student;

mysql> select * from study_record;

3.关联表查询

__author__ = "Burgess Zheng"

import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String,DATE,Enum,ForeignKey
from sqlalchemy.orm import sessionmaker,relationship
from sqlalchemy import func

#创建表
engine = create_engine("mysql+pymysql://python:123@10.0.0.150/burgessdb?charset=utf8",
                       encoding='utf-8', echo=True)
#mysql+pymysql：我们不用写SQL语句，执行的时候调用pymysql执行
#?charset=utf8  可添加中文数据
#echo=True  等于打印整个过程

Base = declarative_base()# 生成orm基类

class Student(Base): #继承Base  (之前数据库存在的表）
    __tablename__ = 'student'  # 表名
    id = Column(Integer, primary_key=True)
    name = Column(String(32),nullable=False)
    register_date = Column(DATE,nullable=False)

    def __repr__(self):#查询返回字段
        return "<%s name:%s>" % (self.id,self.name)

class StudyRecord(Base):
    __tablename__ = 'study_record'
    id = Column(Integer,primary_key=True)
    day = Column(Integer,nullable=False)
    status = Column(String(32),nullable=False)
    stu_id = Column(Integer,ForeignKey("student.id"))#外键关联

    student = relationship("Student",backref="my_study_record")
# relationship：设置关联字段
# 通过student字段可以查student表所有字段的数据
# 允许你在Student表里通过backref字段(my_study_record)反向查出所有它在my_study_record表里的关联项

    def __repr__(self):#查询返回字段
        return "<%s day:%s status:%s>" % (self.id,self.day,self.status)

Base.metadata.create_all(engine)  # 创建表结构

#增删改查需要创建会话（光标）
#这里需要导入sessionmaker：from sqlalchemy.orm import sessionmaker（写在首）
Session_class = sessionmaker(bind=engine)  # 创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例
Session = Session_class()  # 生成session实例 #cursor

'''
#student表增加数据
s1 = Student(name="Burgess",register_date="2014-05-21")
s2 = Student(name="Jack",register_date="2014-03-21")
s3 = Student(name="Rain",register_date="2014-02-21")
s4 = Student(name="Eric",register_date="2013-01-21")

#study_record表正价数据
study_obj1 = StudyRecord(day=1,status="YES",stu_id=1)
study_obj2 = StudyRecord(day=2,status="NO",stu_id=1)
study_obj3 = StudyRecord(day=3,status="YES",stu_id=1)
study_obj4 = StudyRecord(day=1,status="YES",stu_id=2)

Session.add_all([s1,s2,s3,s4,study_obj1,study_obj2,study_obj3,study_obj4])
Session.commit()
'''

stu_obj = Session.query(Student).filter(Student.name=="Burgess").first()
#取student表匹配条件的数据
print(stu_obj.my_study_record)
#由于study_record表引用了student表，
#study_record表里面设置了relationship关联字段backref="my_study_record"
#当我打印student表name的时候调用了my_study_record字段
#所以就会返回StudyRecord类里def __repr__(self)方法里的结果
#最终：显示：[<3 day:1 status:YES>, <4 day:2 status:NO>, <5 day:3 status:YES>]
Session.commit()

[root@python burgess_test]# py orm_foreign_key.py

Python.sqlalchemy多个外键关联同一个表的ID试验（创建表和增删改查分开脚本写）

1.创建表

[root@python burgess_test]# vim orm_multi_foreign_key.py

__author__ = "Burgess Zheng"

from sqlalchemy import Integer, ForeignKey, String, Column
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import relationship
from sqlalchemy import create_engine

#创建表
Base = declarative_base() #生成orm基类

class Customer(Base):
    __tablename__ = 'customer'
    id = Column(Integer, primary_key=True)
    name = Column(String(64))

    billing_address_id = Column(Integer, ForeignKey("address.id"))
    shipping_address_id = Column(Integer, ForeignKey("address.id"))
#两个外键关联同一个address表的ID

    billing_address = relationship("Address",foreign_keys=[billing_address_id])
    shipping_address = relationship("Address",foreign_keys=[shipping_address_id])
#relationship：设置关联字段，允许使用billing_address调取addree表数据

class Address(Base):
    __tablename__ = 'address'
    id = Column(Integer, primary_key=True)
    street = Column(String(64))
    city = Column(String(64))
    state = Column(String(64))

    def __repr__(self):#查询返回字段
        return self.street

engine = create_engine("mysql+pymysql://python:123@10.0.0.150/burgessdb?charset=utf8",
                       encoding='utf-8', echo=True)
#mysql+pymysql：我们不用写SQL语句，执行的时候调用pymysql执行
#?charset=utf8  可添加中文数据
#echo=True  等于打印整个过程

Base.metadata.create_all(engine)  # 创建表结构

[root@python burgess_test]# py orm_multi_foreign_key.py

[root@python ~]# mysql -uroot -p123

mysql> use burgessdb

mysql> show tables;

mysql> show create table customerG

mysql> desc customer;

2.两表增加数据

[root@python burgess_test]# vim orm_api.py

__author__ = "Burgess Zheng"

import orm_multi_foreign_key
#导入创建表模块#等于创建表和增删改查分开脚本写
from sqlalchemy.orm import sessionmaker

#增删改查需要创建会话（光标）
#这里需要导入sessionmaker：from sqlalchemy.orm import sessionmaker（写在首）
Session_class = sessionmaker(bind=orm_multi_foreign_key.engine) # 创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例
Session = Session_class()  # 生成session实例 #cursor

#address表增加数据
addr1 = orm_multi_foreign_key.Address(street="BaoAn",city="SZ",state="GD")
addr2 = orm_multi_foreign_key.Address(street="FuDian",city="SZ",state="GD")
addr3 = orm_multi_foreign_key.Address(street="xixi",city="HZ",state="ZJ")

Session.add_all([addr1,addr2,addr3])
          
#customer表增加数据 
c1 = orm_multi_foreign_key.Customer(name="Burgess",billing_address=addr1,shipping_address=addr2)   
c2 = orm_multi_foreign_key.Customer(name="Jack",billing_address=addr3,shipping_address=addr3)
             
Session.add_all([c1,c2])
Session.commit()

[root@python burgess_test]# py orm_api.py

[root@python ~]# mysql -uroot -p123

mysql> use burgessdb

mysql> select * from address;

mysql> select * from customer;

3.查关联数据

[root@python burgess_test]# vim orm_api.py

__author__ = "Burgess Zheng"

import orm_multi_foreign_key
#导入创建表模块#等于创建表和增删改查分开脚本写
from sqlalchemy.orm import sessionmaker

#增删改查需要创建会话（光标）
#这里需要导入sessionmaker：from sqlalchemy.orm import sessionmaker（写在首）
Session_class = sessionmaker(bind=orm_multi_foreign_key.engine) # 创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例
Session = Session_class()  # 生成session实例 #cursor

'''
#address表增加数据
addr1 = orm_multi_foreign_key.Address(street="BaoAn",city="SZ",state="GD")
addr2 = orm_multi_foreign_key.Address(street="FuDian",city="SZ",state="GD")
addr3 = orm_multi_foreign_key.Address(street="xixi",city="HZ",state="ZJ")

Session.add_all([addr1,addr2,addr3])
          
#customer表增加数据 
c1 = orm_multi_foreign_key.Customer(name="Burgess",billing_address=addr1,shipping_address=addr2)   
c2 = orm_multi_foreign_key.Customer(name="Jack",billing_address=addr3,shipping_address=addr3)
             
Session.add_all([c1,c2])
Session.commit()
'''

#查询
obj = Session.query(orm_multi_foreign_key.Customer).filter(orm_multi_foreign_key.Customer.name=="Burgess").first()
print(obj.name,obj.billing_address,obj.shipping_address)

[root@python burgess_test]# py orm_api.py

Python.sqlalchemy多对多个关系（创建表和增删改查分开脚本写）

1.创建表

[root@python burgess_test]# vim orm_m2m.py

__author__ = "Burgess Zheng"

from sqlalchemy import Table, Column, Integer,String,DATE, ForeignKey
from sqlalchemy.orm import relationship
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker


#创建表
engine = create_engine("mysql+pymysql://python:123@10.0.0.150/burgessdb?charset=utf8",
                       encoding='utf-8', echo=True)
#mysql+pymysql：我们不用写SQL语句，执行的时候调用pymysql执行
#?charset=utf8  可添加中文数据
#echo=True  等于打印整个过程

Base = declarative_base()# 生成orm基类

#Table方式创建表 为什么不用类创建？因为不需要操作，orm自动维护的，无需映射关系
book_m2m_author = Table('book_m2m_author', Base.metadata,
                        Column('book_id',Integer,ForeignKey('books.id')),
                        Column('author_id',Integer,ForeignKey('authors.id')),
                        )



class Book(Base):
    __tablename__ = 'books'
    id = Column(Integer,primary_key=True)
    name = Column(String(64))
    pub_date = Column(DATE)
    authors = relationship('Author',secondary=book_m2m_author,backref='books')
#secondary和backref =后面填写的必须是表名
    def __repr__(self):
        return self.name

class Author(Base):
    __tablename__ = 'authors'
    id = Column(Integer, primary_key=True)
    name = Column(String(32))

    def __repr__(self):
        return self.name

Base.metadata.create_all(engine)  # 创建表结构

[root@python burgess_test]# py orm_m2m.py

[root@python ~]# mysql -uroot -p123

mysql> use burgessdb

mysql> show tables;

mysql> desc authors;

mysql> desc books;

mysql> desc book_m2m_author;

mysql> show create table book_m2m_authorG;

2.表增加数据

[root@python burgess_test]# vim orm_m2m_api.py

__author__ = "Burgess Zheng"

import orm_m2m
from sqlalchemy.orm import sessionmaker

#增删改查需要创建会话（光标）
#这里需要导入sessionmaker：from sqlalchemy.orm import sessionmaker（写在首）
Session_class = sessionmaker(bind=orm_m2m.engine)  # 创建与数据库的会话session class ,>注意,这里返回给session的是个class,不是实例
Session = Session_class()  # 生成session实例 #cursor

#增加数据
b1 = orm_m2m.Book(name="learn python with Burgess",pub_date="2014-05-2")
b2 = orm_m2m.Book(name="learn Zhangbility with Burgess",pub_date="2015-05-2")
b3 = orm_m2m.Book(name="learn hook up girls Burgess",pub_date="2014-05-2")

a1 = orm_m2m.Author(name="Burgess")
a2 = orm_m2m.Author(name="Jack")
a3 = orm_m2m.Author(name="Rain")

b1.authors = [a1, a2]
b3.authors = [a1, a2, a3]

Session.add_all([b1, b2, b3,a1, a2, a3])

Session.commit()

[root@python burgess_test]# py orm_m2m_api.py

[root@python ~]# mysql -uroot -p123

mysql> use burgessdb

mysql> select * from books;

mysql> select * from authors;

mysql> select * from book_m2m_author;

3.查关联数据

[root@python burgess_test]# vim orm_m2m_api.py

__author__ = "Burgess Zheng"

import orm_m2m
from sqlalchemy.orm import sessionmaker

#增删改查需要创建会话（光标）
#这里需要导入sessionmaker：from sqlalchemy.orm import sessionmaker（写在首）
Session_class = sessionmaker(bind=orm_m2m.engine)  # 创建与数据库的会话session class ,>注意,这里返回给session的是个class,不是实例
Session = Session_class()  # 生成session实例 #cursor

'''
#增加数据
b1 = orm_m2m.Book(name="learn python with Burgess",pub_date="2014-05-2")
b2 = orm_m2m.Book(name="learn Zhangbility with Burgess",pub_date="2015-05-2")
b3 = orm_m2m.Book(name="learn hook up girls Burgess",pub_date="2014-05-2")

a1 = orm_m2m.Author(name="Burgess")
a2 = orm_m2m.Author(name="Jack")
a3 = orm_m2m.Author(name="Rain")

b1.authors = [a1, a2]
b3.authors = [a1, a2, a3]

Session.add_all([b1, b2, b3,a1, a2, a3])

Session.commit()
'''

#查询关联数据
author_obj = Session.query(orm_m2m.Author).filter(orm_m2m.Author.name=="Burgess").first()
#print(author_obj.books[1].pub_date
print(author_obj.books)
book_obj = Session.query(orm_m2m.Book).filter(orm_m2m.Book.id==2).first()
print(book_obj.authors)

[root@python burgess_test]# py orm_m2m_api.py

4.删除（记住第三张表也就是外键关联表无需理会，sqlalchemy自动处理的）

Burgess关联了2这本书如果第二本书删除了burgess该作者，那么第二本书自动取消关联作者Burgess

[root@python burgess_test]# vim orm_m2m_api.py

__author__ = "Burgess Zheng"

import orm_m2m
from sqlalchemy.orm import sessionmaker

#增删改查需要创建会话（光标）
#这里需要导入sessionmaker：from sqlalchemy.orm import sessionmaker（写在首）
Session_class = sessionmaker(bind=orm_m2m.engine)  # 创建与数据库的会话session class ,>注意,这里返回给session的是个class,不是实例
Session = Session_class()  # 生成session实例 #cursor

'''
#增加数据
b1 = orm_m2m.Book(name="learn python with Burgess",pub_date="2014-05-2")
b2 = orm_m2m.Book(name="learn Zhangbility with Burgess",pub_date="2015-05-2")
b3 = orm_m2m.Book(name="learn hook up girls Burgess",pub_date="2014-05-2")

a1 = orm_m2m.Author(name="Burgess")
a2 = orm_m2m.Author(name="Jack")
a3 = orm_m2m.Author(name="Rain")

b1.authors = [a1, a2]
b3.authors = [a1, a2, a3]

Session.add_all([b1, b2, b3,a1, a2, a3])

Session.commit()
'''

'''
#查询关联数据
author_obj = Session.query(orm_m2m.Author).filter(orm_m2m.Author.name=="Burgess").first()
#print(author_obj.books[1].pub_date
print(author_obj.books)
book_obj = Session.query(orm_m2m.Book).filter(orm_m2m.Book.id==2).first()
print(book_obj.authors)
'''

#删除
author_obj = Session.query(orm_m2m.Author).filter(orm_m2m.Author.name=="Burgess").first()
print(author_obj)
book_obj = Session.query(orm_m2m.Book).filter(orm_m2m.Book.id==2).first()
book_obj.authors.remove(author_obj)#删除该作者
Session.commit()#提交

[root@python burgess_test]# py orm_m2m_api.py