day13 SQLAlchemy
ORM:也叫关系对象映射
本篇要点：
- 原生模块 pymsql
- ORM框架 SQLAchemy
pymysql
pymsql是Python中操作MySQL的模块，其使用方法和MySQLdb几乎相同。
需要准备的环境：
- MySQL（服务端）
- pymysql（操作客户端）
- pymysql安装参考：http://www.cnblogs.com/woider/p/5926744.html
pymysql的使用操作：
- 执行SQL语句:
SQLAchemy
SQLAlchemy本身无法操作数据库，其必须以来pymsql等第三方插件，Dialect用于和数据API进行交流，根据配置文件的不同调用不同的数据库API，从而实现对数据库的操作，如：
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
- 创建表：
#!/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:123456@10.70.18.100:3306/ttt",max_overflow=5) #连接数据库
Base = declarative_base()
#创建单表：
class Users(Base): #类必须要继承Base
__tablename__ = 'users' #表名
id = Column(Integer,primary_key=True) #创建列
name = Column(String(32))
extra = Column(String(16))
__table_args__ = (
UniqueConstraint('id','name',name='centos'), #联合索引
Index('ix_id_name','name','extra'),
)
#一对多
class Favor(Base):
__tablename__ = 'favor'
nid = Column(Integer,primary_key=True)
caption = Column(String(50),default='red',unique=True)
class Person(Base):
__tablename__ = 'person'
nid = Column(Integer,primary_key=True)
name = Column(String(32),index=True,nullable=True)
favor_id = Column(Integer,ForeignKey("favor.nid")) #根上一个favor的nid做外键
#多对多
class ServerToGroup(Base):
__tablename__ = 'servertogroup'
id = Column(Integer,primary_key=True,autoincrement=True)
hostname = Column(String(64),unique=True,nullable=False)
class Group(Base):
__tablename__ = 'group'
id = Column(Integer,primary_key=True)
name = Column(String(64),unique=True,nullable=False)
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)
# def init_db():
# Base.metadata.create_all(engine)
# init_db() #创建
def drop_db():
Base.metadata.drop_all(engine)
drop_db() #删除
- 表操作（增删改查）
1.增加操作
#!/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:123456@10.70.18.100:3306/ttt",max_overflow=5,encoding='utf-8', echo=True) #连接数据库
Base = declarative_base()
#创建单表：
class Users(Base): #类必须要继承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='centos'), #联合索引
Index('ix_id_name','name','extra'),
)
def init_db(): # 首先要创建单表
Base.metadata.create_all(engine)
init_db() #初始化表
Session = sessionmaker(bind=engine) #会话绑定
session = Session()
obj = Users(name='wanghui',extra='ssss') #单条数据操作
session.add(obj) #增加单条数据
session.add_all([ #多条数据的增加
Users(name='xyz',extra='wsss'),
Users(name='sssd',extra='dadsad'),
Users(name='jack',extra='hello'),
Users(name='jack1',extra='hello'),
Users(name='jack2',extra='hello'),
Users(name='jack3',extra='hello')
])
session.commit() #提交
2.删除操作
#!/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:123456@10.70.18.100:3306/ttt",max_overflow=5,encoding='utf-8', echo=True) #连接数据库
Base = declarative_base()
#创建单表：
class Users(Base): #类必须要继承Base
__tablename__ = 'users' #表名
id = Column(Integer,primary_key=True) #创建列
name = Column(String(32))
extra = Column(String(16))
__table_args__ = (
UniqueConstraint('id','name',name='centos'), #联合索引
Index('ix_id_name','name','extra'),
)
# def init_db(): # 首先要创建单表
# Base.metadata.create_all(engine)
# init_db() #初始化表
Session = sessionmaker(bind=engine) #会话绑定
session = Session()
session.query(Users).filter(Users.id > 2).delete() #删除的话也是根据条件进行伤处操作的
session.commit()
3.修改操作
#!/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:123456@10.70.18.100:3306/ttt",max_overflow=5,encoding='utf-8', echo=True) #连接数据库
Base = declarative_base()
#创建单表：
class Users(Base): #类必须要继承Base
__tablename__ = 'users' #表名
id = Column(Integer,primary_key=True) #创建列
name = Column(String(32))
extra = Column(String(16))
__table_args__ = (
UniqueConstraint('id','name',name='centos'), #联合索引
Index('ix_id_name','name','extra'),
)
# def init_db(): # 首先要创建单表
# Base.metadata.create_all(engine)
# init_db() #初始化表
Session = sessionmaker(bind=engine) #会话绑定
session = Session()
session.query(Users).filter(Users.id > 2 ).update({'name':'099'})
session.query(Users).filter(Users.id > 2).update({Users.name:Users.name + '099'},synchronize_session = False)
session.commit()
4.查找操作
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#!/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:123456@10.70.18.100:3306/ttt",max_overflow=5,encoding='utf-8', echo=True) #连接数据库
Base = declarative_base()
#创建单表：
class Users(Base): #类必须要继承Base
__tablename__ = 'users' #表名
id = Column(Integer,primary_key=True) #创建列
name = Column(String(32))
extra = Column(String(16))
__table_args__ = (
UniqueConstraint('id','name',name='centos'), #联合索引
Index('ix_id_name','name','extra'),
)
# def init_db(): # 首先要创建单表
# Base.metadata.create_all(engine)
# init_db() #初始化表
Session = sessionmaker(bind=engine) #会话绑定
session = Session()
ret1=session.query(Users).all() #查询全部
ret2=session.query(Users.name,Users.extra).all()
ret3=session.query(Users).filter_by(name='099099').all() #条件匹配查
ret4=session.query(Users).filter_by(name='099099').first()
print(ret1[0].name,ret1[0].id,ret1[0].extra) #获取第一行数据
print(ret1[1].name,ret1[1].id,ret1[1].extra) #获取第二行的数据
5.其他操作
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#!/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
from sqlalchemy import all_,and_,or_,not_ #导入条件判断语句
engine = create_engine("mysql+pymysql://root:123456@10.70.18.100:3306/ttt",max_overflow=5,encoding='utf-8', echo=True) #连接数据库
Base = declarative_base()
#创建单表：
class Users(Base): #类必须要继承Base
__tablename__ = 'users' #表名
id = Column(Integer,primary_key=True) #创建列
name = Column(String(32))
extra = Column(String(16))
__table_args__ = (
UniqueConstraint('id','name',name='centos'), #联合索引
Index('ix_id_name','name','extra'),
)
# def init_db(): # 首先要创建单表
# Base.metadata.create_all(engine)
# init_db() #初始化表
Session = sessionmaker(bind=engine) #会话绑定
session = Session()
#条件
ret = session.query(Users).filter_by(name='wanghui').all() #条件过滤 （单个条件可以用filter_by）
#print(ret[0].name,ret[0].id,ret[0].extra) #打印查查找的数据信息
res = session.query(Users).filter_by(name='wanghui')
print(res) #打印操作的SQL语句
ret1 = session.query(Users).filter(Users.id > 1 , Users.name == 'wanghui').all() #匹配查询（多个条件就不用filter_by了）
#print(ret[0].name,ret[0].id,ret[0].extra)
ret2=session.query(Users).filter(Users.id.between(1,35),Users.name=='wanghui').all() #条件查询
ret3=session.query(Users).filter(Users.id.in_([1,34,40])).all()
ret4=session.query(Users).filter(~Users.id.in_([1,34,40])).all() #非操作
ret5=session.query(Users).filter(and_(Users.id > 3,Users.name=='wanghui')).all() #与操作
ret6=session.query(Users).filter(or_(Users.id > 3,Users.name=='wanghui')).all() #或操作
ret7=session.query(Users).filter(
or_(
Users.id > 2,
and_(Users.name == 'wanghui',Users.id > 10),
Users.extra != ''
)).all()
#通配符
ret8 = session.query(Users).filter(Users.name.like('e%')).all() #模糊匹配
ret9 = session.query(Users).filter(~Users.name.like('e%')).all() #模糊匹配
#限制
ret10 = session.query(Users).filter(Users.id)[1:2]
#排序
ret11 = session.query(Users).order_by(Users.extra.desc()).all() #desc表示逆序，asc表示顺序
ret12=session.query(Users).order_by(Users.name.desc(),Users.id.asc()).all()
#分组
from sqlalchemy.sql import func
ret13 = session.query(Users).group_by(Users.extra).all()
ret14 = 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()
连表操作：
为什么要分表：
解决数据冗余的问题
约束问题：外键
单表查询：
#!/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:123456@10.70.18.100:3306/zzz",max_overflow=5,encoding='utf-8') #连接数据库
# engine = create_engine("mysql+pymysql://root:123456@10.70.18.100:3306/zzz",max_overflow=5,encoding='utf-8', echo=True) #连接数据库
Base = declarative_base()
#建表
class Test(Base):
__tablename__='test'
nid=Column(Integer,primary_key=True,autoincrement=True)
name=Column(String(32))
#一对多表
class Group(Base):
__tablename__='group'
nid=Column(Integer,primary_key=True,autoincrement=True)
caption=Column(String(32))
class User(Base):
__tablename__='user'
nid=Column(Integer,primary_key=True,autoincrement=True)
username=Column(String(32))
group_id=Column(Integer,ForeignKey(Group.nid)) #和group的id建立关系
def __repr__(self): #当加入repr定义的字符格式的时候会把非映射关系的数据按照tmp定义的格式输出
tmp = '%s - %s - %s'%(self.nid,self.username,self.group_id)
return tmp
#生成表
def init_db():
Base.metadata.create_all(engine)
init_db()
Session = sessionmaker(bind=engine) #会话绑定
session = Session()
session.add_all([ #插入组数据
Group(caption='DBA'),
Group(caption='OPS')
])
session.add_all([ #插入用户数据
User(username='alex',group_id=1),
User(username='wanghui',group_id=2)
])
session.commit()
ret=session.query(User).filter(User.username=='wanghui').all() #将收集的数据存储成为一个list对象
print(ret)
obj=ret[0]
print(obj)
print(obj.username)
print(obj.group_id)
print(obj.nid)
ret1=session.query(User.username).all() #这样的话可以直接获取数据（加上映射之后就可以取到数据了）
print(ret1)
正向查找：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#!/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:123456@10.70.18.100:3306/zzz",max_overflow=5,encoding='utf-8') #连接数据库
# engine = create_engine("mysql+pymysql://root:123456@10.70.18.100:3306/zzz",max_overflow=5,encoding='utf-8', echo=True) #连接数据库
Base = declarative_base()
#建表
class Test(Base):
__tablename__='test'
nid=Column(Integer,primary_key=True,autoincrement=True)
name=Column(String(32))
#一对多表
class Group(Base):
__tablename__='group'
nid=Column(Integer,primary_key=True,autoincrement=True)
caption=Column(String(32))
class User(Base):
__tablename__='user'
nid=Column(Integer,primary_key=True,autoincrement=True)
username=Column(String(32))
group_id=Column(Integer,ForeignKey(Group.nid)) #和group的id建立关系
group=relationship('Group',backref='uuu') #解决查询时候的连表关系,
def __repr__(self): #当加入repr定义的字符格式的时候会把非映射关系的数据按照tmp定义的格式输出
tmp = '%s - %s - %s'%(self.nid,self.username,self.group_id)
return tmp
#生成表
def init_db():
Base.metadata.create_all(engine)
init_db()
Session = sessionmaker(bind=engine) #会话绑定
session = Session()
# session.add_all([ #插入组数据
# Group(caption='DBA'),
# Group(caption='OPS')
# ])
# session.add_all([ #插入用户数据
# User(username='alex',group_id=1),
# User(username='wanghui',group_id=2)
# ])
# session.commit()
#连表操作
#正向查询方式
ret=session.query(User).all()
for obj in ret: #obj代指user表的nid，obj
print(obj.nid,obj.username,obj.group_id,obj.group.nid,obj.group.caption)
反向查找：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#!/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:123456@10.70.18.100:3306/zzz",max_overflow=5,encoding='utf-8') #连接数据库
# engine = create_engine("mysql+pymysql://root:123456@10.70.18.100:3306/zzz",max_overflow=5,encoding='utf-8', echo=True) #连接数据库
Base = declarative_base()
#建表
class Test(Base):
__tablename__='test'
nid=Column(Integer,primary_key=True,autoincrement=True)
name=Column(String(32))
#一对多表
class Group(Base):
__tablename__='group'
nid=Column(Integer,primary_key=True,autoincrement=True)
caption=Column(String(32))
class User(Base):
__tablename__='user'
nid=Column(Integer,primary_key=True,autoincrement=True)
username=Column(String(32))
group_id=Column(Integer,ForeignKey(Group.nid)) #和group的id建立关系
group=relationship('Group',backref='uuu') #解决查询时候的连表关系,
def __repr__(self): #当加入repr定义的字符格式的时候会把非映射关系的数据按照tmp定义的格式输出
tmp = '%s - %s - %s'%(self.nid,self.username,self.group_id)
return tmp
#生成表
# def init_db():
# Base.metadata.create_all(engine)
# init_db()
#
Session = sessionmaker(bind=engine) #会话绑定
session = Session()
#
# session.add_all([ j #插入组数据
# Group(caption='DBA'),
# Group(caption='OPS')
# ])
# session.add_all([ #插入用户数据
# User(username='alex',group_id=1),
# User(username='wanghui',group_id=2)
# ])
# session.commit()
#连表操作
# sql=session.query(User.username,Group.caption).join(Group,isouter=True).filter(Group.caption=='DBA')
# print(sql)
# ret=session.query(User.username,Group.caption).join(Group,isouter=True).filter(Group.caption=='DBA').all() #isouter:表示left JOIN
# print(ret)
#反向查询
res=session.query(Group).filter(Group.caption=='DBA').first()
print(res.nid)
print(res.caption)
print(res.uuu)
多对多数据创建与操作：
多对多使用背景：
多机器，多用户，多权限
类似于下图的格式：
对于主机c1来说都存在与之对应的服务器用户，所以要建立用户和服务器指之间的关联关系，就要出现一张新的表来对应他们之间的关系表：
外键约束；
#!/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:123456@10.70.18.100:3306/zzz",max_overflow=5,encoding='utf-8') #连接数据库
# engine = create_engine("mysql+pymysql://root:123456@10.70.18.100:3306/zzz",max_overflow=5,encoding='utf-8', echo=True) #连接数据库
Base = declarative_base()
#建表
class Group(Base):
__tablename__='group'
nid=Column(Integer,primary_key=True,autoincrement=True)
caption=Column(String(32))
class User(Base):
__tablename__='user'
nid=Column(Integer,primary_key=True,autoincrement=True)
username=Column(String(32))
group_id=Column(Integer,ForeignKey(Group.nid)) #和group的id建立关系
group=relationship('Group',backref='uuu') #解决查询时候的连表关系,
def __repr__(self): #当加入repr定义的字符格式的时候会把非映射关系的数据按照tmp定义的格式输出
tmp = '%s - %s - %s'%(self.nid,self.username,self.group_id)
return tmp
class Host(Base):
__tablename__='host'
nid=Column(Integer,primary_key=True,autoincrement=True)
hostname=Column(String(32))
port=Column(String(32))
ip=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'))
#创建表
# def init_db():
# Base.metadata.create_all(engine)
# init_db()
Session=sessionmaker(bind=engine)
session=Session()
#创建数据
# session.add_all([
# Host(hostname='c1',port=22,ip='192.168.1.1'),
# Host(hostname='c2',port=22,ip='192.168.1.2'),
# Host(hostname='c3',port=22,ip='192.168.1.3'),
# Host(hostname='c4',port=22,ip='192.168.1.4'),
# Host(hostname='c5',port=22,ip='192.168.1.5'),
# ])
# session.add_all([
# HostUser(username='root'),
# HostUser(username='wanghui'),
# HostUser(username='zzd'),
# HostUser(username='ys'),
# ])
#创建对应关系数据
# 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=1),
# HostToHostUser(host_id=2,host_user_id=2),
# HostToHostUser(host_id=2,host_user_id=3),
# ])
# session.commit()
#获取主机1中的用户数据
推荐方式：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#!/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,Table
from sqlalchemy.orm import sessionmaker,relationship
engine = create_engine("mysql+pymysql://root:123456@10.70.18.100:3306/zzz",max_overflow=5,encoding='utf-8') #连接数据库
# engine = create_engine("mysql+pymysql://root:123456@10.70.18.100:3306/zzz",max_overflow=5,encoding='utf-8', echo=True) #连接数据库
Base = declarative_base()
#建表
class Group(Base):
__tablename__='group'
nid=Column(Integer,primary_key=True,autoincrement=True)
caption=Column(String(32))
class User(Base):
__tablename__='user'
nid=Column(Integer,primary_key=True,autoincrement=True)
username=Column(String(32))
group_id=Column(Integer,ForeignKey(Group.nid)) #和group的id建立关系
group=relationship('Group',backref='uuu') #解决查询时候的连表关系,
def __repr__(self): #当加入repr定义的字符格式的时候会把非映射关系的数据按照tmp定义的格式输出
tmp = '%s - %s - %s'%(self.nid,self.username,self.group_id)
return tmp
class HostToHostUser(Base): #关系表
__tablename__ = 'host_to_host_user'
nid=Column(Integer,primary_key=True,autoincrement=True) #自己的主键
host_id=Column(Integer,ForeignKey('host.nid')) #创建host外键
host_user_id=Column(Integer,ForeignKey('host_user.nid')) #创建user外键
class Host(Base):
__tablename__='host'
nid=Column(Integer,primary_key=True,autoincrement=True)
hostname=Column(String(32))
port=Column(String(32))
ip=Column(String(32))
host_user=relationship('HostUser',secondary=HostToHostUser.__table__,backref='host_list') #正向查找和反向查找
class HostUser(Base):
__tablename__='host_user'
nid=Column(Integer,primary_key=True,autoincrement=True)
username=Column(String(32))
#创建表
# def init_db():
# Base.metadata.create_all(engine)
# init_db()
Session=sessionmaker(bind=engine)
session=Session()
#创建host数据
# session.add_all([
# Host(hostname='c1',port=22,ip='192.168.1.1'),
# Host(hostname='c2',port=22,ip='192.168.1.2'),
# Host(hostname='c3',port=22,ip='192.168.1.3'),
# Host(hostname='c4',port=22,ip='192.168.1.4'),
# Host(hostname='c5',port=22,ip='192.168.1.5'),
# ])
#插入用户
# session.add_all([
# HostUser(username='root'),
# HostUser(username='wanghui'),
# HostUser(username='zzd'),
# HostUser(username='ys'),
# ])
#创建对应关系数据
# 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=1),
# HostToHostUser(host_id=2,host_user_id=),
# HostToHostUser(host_id=2,host_user_id=3),
# ])
# session.commit()
host_obj=session.query(Host).filter(Host.hostname=='c1').first()
print(host_obj.host_user)
整体思想
1.创建表和操作表
2.操作表：
单表操作：转换操作
连表操作：.join
创建关系：
一对多：正向查找，反向查找
多对多：多一张关系表
