Python的Django框架中使用SQLAlchemy操作数据库的教程
作者：刘天斯
字体：[ ] 类型：转载 时间：
SQLAlchemy是Python一个专门的数据库管理工具,如果对Django ORM觉得有些生疏的话完全可以结合SQLAlchemy,这里我们就来总结一下Python的Django框架中使用SQLAlchemy操作数据库的教程
零、SQLAlchemy是什么？
SQLAlchemy的官网上写着它的介绍文字:
SQLAlchemy is the Python SQL toolkit and Object Relational Mapper that gives
application developers the full power and flexibility of SQL.
SQLAlchemy 是一个非常强大的ORM和数据库工具，但是它庞大的文档和复杂的功能总是让很 多人望而生畏。而Django的ORM相对来说就让很多人觉得简单实用。
事实上，SQLAlchemy其实也没有那么复杂，光使用它一些比较高级的功能其实并没有比 使用Django ORM复杂多少，而它丰富的功能则能让你在遇到更复杂的问题时处理起来得心应手。
写作本文的主要目的在于：
通过对比SQLAlchemy ORM和Django ORM的主要使用方法， 尽量简单直观的让Django用户能够快速了解和上手SQLAlchemy这款强大的工具。
不牵扯到SQLAlchemy具体的技术细节，包括Engine连接池、Session的具体工作原理等等
SQLAlchemy相对于Django内建的ORM来说，有几处非常明显的优点：
可独立使用，任何使用Python的项目都可以用它来操作数据库
和直接使用原始的DBAPI相比，提供了非常丰富的特性：连接池、auto-map等等
提供了更底层的SQL抽象语言，能用原始sql解决的问题基本上都可以用SQLAlchemy解决
接下来我们针对日常的数据库操作来对比一下Django ORM和SQLAlchemy。
文中使用的 SQLAlchemy 版本为 0.9.8
一、Django VS SQLAlchemy
SQLAlchemy的安装：
wget /dist/ez_setup.py
python ez_setup.py
sudo easy_install sqlalchemy
sudo easy_install ipython
1.建立数据表
首先，我们需要先建立几个表。
（1）Django
在Django中，如果要建表，就是在models.py中定义你的数据类型：
from django.db import models
class Game(models.Model):
class GameCompany(models.Model):
因为文章主要面向有经验的Django用户，所以此处不写出详细的定义代码。定义Model以后 我们还需要在settings.py中DATABASES处设置需要连接的数据库地址。最后，使用syncdb来 完成数据库表的创建。
（2）SQLAlchemy
在SQLAlchemy中，定义表结构的过程和Django类似：
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, Date
from sqlalchemy.orm import relationship, backref
Base = declarative_base()
# 定义表结构
class GameCompany(Base):
__tablename__ = 'game_company'
id = Column(Integer, primary_key=True)
name = Column(String(200), nullable=False)
country = Column(String(50))
class Game(Base):
__tablename__ = 'game'
id = Column(Integer, primary_key=True)
company_id = Column(Integer, ForeignKey('game_company.id'), index=True)
category = Column(String(10))
name = Column(String(200), nullable=False)
release_date = Column(Date)
# 和Django不同，外键需要显式定义，具体好坏见仁见智
# 此处的relation可以为lazy加载外键内容时提供一些可配置的选项
company = relationship('GameCompany', backref=backref('games'))
# 此处定义要使用的数据库
engine = create_engine('mysql://root:root@localhost:5379/sqlalchemy_tutorial?charset=utf8')
# 调用create_all来创建表结构，已经存在的表将被忽略
Base.metadata.create_all(engine)
2.插入一些数据
接下来，我们往表中插入一些数据
（1）Django
Django中比较常用的插入数据方法就是使用 .save() 了。
nintendo = GameCompany(name="nintendo", country="Japan")
nintendo.save()
game1 = Game(
company=nintendo,
category="ACT",
name="Super Mario Bros",
release_date='')
game1.save()
# 或者使用create
Game.objects.create(... ...)
（2）SQLAlchemy
在SQLAlchemy ORM中，有一个非常关键的对象 session ，所有对于数据的操作都是 通过session来进行的，所以要插入数据之前，我们得先初始化一个session：
from sqlalchemy.orm import sessionmaker
Session = sessionmaker(bind=engine)
session = Session()
之后插入数据的方法也和Django比较相似：
# 添加数据
nintendo = GameCompany(name="Nintendo", country="Japan")
capcom = GameCompany(name="Capcom", country="Japan")
game1 = Game(
company=nintendo,
category="ACT",
name="Super Mario Bros",
release_date=''
game2 = Game(
company=capcom,
category="ACT",
name="Devil May Cry 3: Dante's Awakening",
release_date="",
game3 = Game(
company=nintendo,
category="RPG",
name="Mario & Luigi: Dream Team",
release_date="",
# 使用add_all来让这些objects和session产生关系
session.add_all([nintendo, capcom, game1, game2])
# 在没有开启autocommit的模式下，不要忘了调用commit来让数据写到数据库中
除了commit之外，session还有rollback()等方法，你可以把session对象简单看成是一次 transaction，所以当你对内容进行修改时，需要调用 mit() 来提交这些修改。
去文档可以了解更多session相关内容：http://docs.sqlalchemy.org/en/rel_0_9/orm/session.html
二、常用操作
1.简单查询
（1）批量查询
# -- Django --
Game.objects.filter(category="RPG")
# -- SQLAlchemy --
# 使用filter_by是和django ORM比较接近的方式
session.query(Game).filter_by(category="RPG")
session.query(Game).filter(Game.category == "RPG")
（2）查询单个对象
# -- Django --
Game.objects.get(name="Super Mario Bros")
# -- SQLAlchemy --
session.query(Game).filter_by(name="Super Mario Bros").one()
# `get_objects_or_None()`
session.query(Game).filter_by(name="Super Mario Bros").scalar()
Django中得各种 & 、& 都是使用在字段名称后面追加 "__gt"、"__lt" 来实现的，在SQLAlchemy 中这样的查询还要更直观一些
# -- Django --
Game.objects.filter(release_date__gte='')
Game.objects.exclude(release_date__gte='')
# -- SQLAlchemy --
session.query(Game).filter(Game.release_date &= '').count()
# 取反使用 ~ 运算符
session.query(Game).filter(~Game.release_date &= '').count()
通过外键组合查询
# -- Django --
Game.objecs.filter(company__name="Nintendo")
# -- SQLAlchemy --
session.query(Game).join(GameCompany).filter(GameCompany.name == "Nintendo")
2.多条件或查询
# -- Django --
from django.db.models import Q
Game.objects.filter(Q(category="RPG") | Q(category="ACT"))
# -- SQLAlchemy --
from sqlalchemy import or_
session.query(Game).filter(or_(Game.category == "RPG", Game.category == "ACT"))
session.query(Game).filter((Game.category == "RPG") | (Game.category == "ACT"))
（1）in查询
# -- Django --
Game.objects.filter(category__in=["GAL", "ACT"])
# -- SQLAlchemy --
session.query(Game).filter(Game.category.in_(["GAL", "ACT"]))
（2）like查询
# -- Django --
Game.objects.filter(name__contains="Mario")
# -- SQLAlchemy --
session.query(Game.name.contains('Mario'))
3.统计个数
简单统计总数：
# -- Django --
Game.objects.filter(category="RPG").count()
# -- SQLAlchemy --
session.query(Game).filter_by(category="RPG").count()
分组统计个数
# -- Django --
from django.db.models import Count
Game.objects.values_list('category').annotate(Count('pk')).order_by()
# -- SQLAlchemy --
from sqlalchemy import func
session.query(Game.category, func.count(Game.category)).group_by(Game.category).all()
4.结果排序
对查询结果进行排序：
# -- Django --
Game.objects.all().order_by('release_date')
Game.objects.all().order_by('-release_date')
# 多字段排序
Game.objects.all().order_by('-release_date', 'category')
# -- SQLAlchemy --
session.query(Game).order_by(Game.release_date)
session.query(Game).order_by(Game.release_date.desc())
# 多字段排序
session.query(Game).order_by(Game.release_date.desc(), Game.category)
5.修改数据
# -- Django --
game = Game.objects.get(pk=1)
game.name = 'Super Mario Brothers'
game.save()
# -- SQLAlchemy --
game = session.query(Game).get(1)
game.name = 'Super Mario Brothers'
6.批量修改
# -- Django --
Game.objects.filter(category="RPG").update(category="ARPG")
# -- SQLAlchemy --
session.query(Game).filter_by(category="RPG").update({"category": "ARPG"})
7.批量删除
# -- Django --
Game.objects.filter(category="ARPG").delete()
# -- SQLAlchemy --
session.query(Game).filter_by(category="ARPG").delete()
三、SQLAlchemy其他一些值得关注的功能
上面简单列了一些SQLAlchemy ORM和Django ORM的使用方法对比，SQLAlchemy同时还提供了一些 其他非常有用的功能，比如Automap~
假如你有一个Django项目，通过ORM创建了一大堆Model。这时来了一个新项目，需要操作 这些表，应该怎么办？拷贝这些Models？使用原始的DB-API加上sql来操作？
其实使用SQLAlchemy的Automap可以让你的工作变得非常的方便，你只要在新项目连接到旧数据库，然后 稍微配置一下Automap，就可以使用SQLAlchemy的ORM操作那些通过别的系统创建的表了。
就像这样：
from sqlalchemy.ext.automap import automap_base
from sqlalchemy.orm import Session
from sqlalchemy import create_engine
Base = automap_base()
engine = create_engine("sqlite:///mydatabase.db")
Base.prepare(engine, reflect=True)
# user和address就是表明，通过这样的语句就可以把他们分别映射到User和Address类
User = Base.classes.user
Address = Base.classes.address
更多信息可以参考详细文档：http://docs.sqlalchemy.org/en/rel_0_9/orm/extensions/automap.html
附：Django与SQLAlchemy结合的实例演示
譬如，以下gumi/db.py代码，其中gumi制作Django项目名，项目中使用的唯一的数据库连接的包装，作为py调用。
# -*- coding: utf-8 -*-
from django.conf import settings
from django.core import signals
from django.dispatch import dispatcher
import sqlalchemy
from sqlalchemy.orm import scoped_session, sessionmaker
from sqlalchemy.engine.url import URL
__all__ = ['Session', 'metadata']
def create_engine():
url = URL(drivername=settings.DATABASE_ENGINE,
database=settings.DATABASE_NAME,
username=settings.DATABASE_USER,
password=settings.DATABASE_PASSWORD,
host=settings.DATABASE_HOST,
port=settings.DATABASE_PORT or None,
query = getattr(settings, 'DATABASE_OPTIONS', {})
options = getattr(settings, 'SQLALCHEMY_OPTIONS', {})
engine = sqlalchemy.create_engine(url, **options)
return engine
def end_request(signal, sender):
Session.remove()
dispatcher.connect(receiver=end_request,
signal=signals.request_finished)
metadata = sqlalchemy.MetaData()
Session = scoped_session(sessionmaker(autoflush=True,
transactional=True,
bind=create_engine()))
from sqlalchemy.orm import *
from gumi.db import Session, metadata
some_table = Table('some_table', metadata,
Column('id', Integer, primary_key=True),
Column('some_value', String(100), nullable=False,
mysql_engine='InnoDB',
class SomeObject(object):
mapper(SomeObject, some_table)
import django.newforms as forms
from gumi.db import Session
class SomeForm(forms.Form):
def some_action(req):
if req.method != "POST":
form = SomeForm()
form = SomeForm(req.POST)
if form.is_valid():
data = form.clean()
obj = SomeObject()
obj.some_param = data['a']
obj.another_param = data['b']
Session.save(obj)
return HttpResponseRedirect('/')
return render_to_response('some/template.html')
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具随笔 - 19&
文章 - 1&评论 - 0&trackbacks - 0
一、ORM& & & & 连表& & & & & & & 一对多& & & & & & & 1、创建表，主动指定外键约束。& & & & & & & 2、操作。& & & & & & & & & & & & & 类：repr& & & & & & & & & &一对多：& & & & & & & & & & & & & 单表& && & & & & & & & & & & & & 连表& & & & & & & & & & & & & & & & session.query（表1).join（表2）.all( )& & & & & & & & & & &多对多：& & & & & & & & & & & & & & & & 1、创建表，额外的关系表。& & & & & & & & & & & & & & & & 2、filter( ) &_in( ) &把结果可传进去。 & & & & & &&& & & & & & & & & & & & & & & & 3、relationship& & & & & & & & & & & & & & & & & & &A& & & & & & & & & & & & & & & & & & &A_B ==& 【关系表】 relationship 字段 和 primary_key 字段常放在这里。& & & & & & & & & & & & & & & & & & &B & & & & &PS：通过A 找到 A_B 关系的时候，是反向找；& & & & & & & & & & & & & & & & & & & & & & & & & & & & 而通过关系找到某一个，是正向找。& & & & & & & & & &&提示：1、这个关系表不一定要放在A_B 关系表中，其他地方也能放。比如、可以放在A中。& & & & & & & & & & & & & & & 2、关系表不影响具体的代码。from sqlalchemy import create_enginefrom sqlalchemy.ext.declarative import declarative_basefrom sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Indexfrom sqlalchemy.orm import sessionmaker, relationshipengine = create_engine("mysql+pymysql://root:123qwe@192.168.1.100:3306/s08day11", max_overflow=5)
#定义引擎。Base = declarative_base()# 一对多 例如:一个人只能在一个组里。class Group(Base):
__tablename__
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_ = relationship("Favor", backref='pers')
# （2）通过对象方式
#这样看起来不方便，可以自己进行自定制,只是让 print 时候好看些。
def __repr__(self):
#这里定义什么就可以返回并看到什么。因为在sqlalchemy 中使用了 __repr__()内部规定的方法。
temp = '%s -- %s: %s' % (self.nid,self.username,self.group_id)
return tempdef init_db():
Base.metadata.create_all(engine)def drop_db():
Base.metadata.drop_all(engine)# init_db()
#创建数据库Session=sessionmaker(bind=engine)
#绑定元信息session=Session()####### 添加 插入 数据session.add(Group(caption='DBA'))session.add(Group(caption='SA'))session.add(Group(caption='SA'))#mit()session.add_all([
User(username='alex',group_id=1),
User(username='eric',group_id=2),
User(username='jack',group_id=3)])#mit()############# 单表查询 ##################1、只是获取 user 表的 用户信息。（1）通过对象方式ret= session.query(User).filter(User.username == 'alex').all()print(ret)
#ret 有多个对象obj=ret[0]
#获取到了对象print(obj.nid)print(obj.username)print(obj.group.id)print('================================')#2、获取所有 user 表用户信息。（2） 通过映射方式ret=session.query(User.username).all()print(ret)############## 连表查询 ###############sql=session.query(User).join(Group,isouter=True) #isouter 为True 打印出sql语句.print(sql)print('=================================')ret=session.query(User).join(Group,isouter=True).all() #join 联表操作。print(ret)print('=================================')#如果想把两个【表】的内容都拿到的话。ret=session.query(User,Group).join(Group,isouter=True).all()print(ret)ret=session.query(User.username,Group.caption).join(Group,isouter=True).all()print(ret)
#在列表中，有一个元祖，元祖中存放着 User表对象和 Group 表执行结果：通过对象的方式展示出来了，如果不想通过对象的话，[1 -- alex: 1]1============================================[('alex',), ('eric',), ('jack',)]SELECT "user".nid AS user_nid, "user".username AS user_username, "user".group_id AS user_group_idFROM "user" LEFT OUTER JOIN "group" ON "group".nid = "user".group_id============================================[1 -- alex: 1, 2 -- eric: 2, 3 -- jack: 3]============================================[(1 -- alex: 1, &__main__.Group object at 0xCD9A6D8&), (2 -- eric: 2, &__main__.Group object at 0xCD9A780&), (3 -- jack: 3, &__main__.Group object at 0xCD9A828&)][('alex', 'DBA'), ('eric', 'SA'), ('jack', 'SA')]上述中, 通过对象的方式展示出来了，如果不想通过对象的话，这样的方式很麻烦, 所以
与生成表结构无关，仅用于查询方便
group = relationship("Favor", backref='pers')
于是使用 group=relationship('Group',backref='uuu') 就可以了。2、使用&relationship&方式不用联表，sqlalchemy 内部帮你联表操作了。& &&【一对多】数据库数据如下：& & & &&from sqlalchemy import create_enginefrom sqlalchemy.ext.declarative import declarative_basefrom sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Indexfrom sqlalchemy.orm import sessionmaker, relationshipengine = create_engine("mysql+pymysql://root:123qwe@10.10.31.99:3306/s08day11", max_overflow=5)
#定义引擎。Base = declarative_base()############# 正向查找 和反向查找 ################# 一对多class Group(Base):
__tablename__
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=relationship('Group',backref='uuu')
# 释义：这种 backref='uuu' 会在Group表中加上一个 uuu,直接 Group.uuu 表示找到跟这个组对应的所有的用户。
def __repr__(self):
temp = '%s -- %s: %s' % (self.nid,self.username,self.group_id)
return tempSession=sessionmaker(bind=engine)session=Session()Base.metadata.create_all(engine) #创建表#1、新方式【正向查询】ret = session.query(User).all()for obj in ret:
# obj 代表user 表的每一行数据
# obj.group 代指 group 对象。
print(obj.nid, obj.username,'======', obj.group_id ,obj.group_id, obj.group.caption,':=',obj.group )print('=================','\n')# 2、【原始方式】; 查询所有DBA的信息。ret = session.query(User.username,Group.caption).join(Group, isouter=True).filter(Group.caption == 'DBA').all()print(ret)print('=================','\n')# 3、新方式 【返向查询】obj= session.query(Group).filter(Group.caption=='DBA').first()print(obj.nid)print(obj.caption)print(obj.uuu)
#通过反向查找Group表中。找到了关于DBA的组的所有user成员，
# 并以列表返回 [1 -- alex: 1, 2 -- eric: 2, 3 -- jack: 3] 执行结果：1 alex ====== 1 1 DBA := &__main__.Group object at 0xFA898&2 eric ====== 2 2 SA := &__main__.Group object at 0xFAA58&3 jack ====== 3 3 SA := &__main__.Group object at 0xFAC18&4 alex1 ====== 1 1 DBA := &__main__.Group object at 0xFA898&================= [('alex', 'DBA'), ('alex1', 'DBA')]================= 1DBA[1 -- alex: 1, 4 -- alex1: 1]正向查找和反向查找& 一般情况下，foreignKey和relationship 是在一起的。& 当我们通过 Group 表找User表的时候，backref=uuu，没有在此表中定义，所以通过Group 查找User表的时候，为反向查找。& 如下图展示：写成 Table对象也可以。& &过程：由 class类转换为 Table对象 ，下面例子是没有写类 直接写 Table对象也可以，一模一样的。from sqlalchemy import create_engine, Table, Column, Integer, String, MetaData, ForeignKeymetadata = MetaData()user = Table('user', metadata,
Column('id', Integer, primary_key=True),
Column('name', String(20)),)Host= Table('host', metadata,
Column('id', Integer, primary_key=True),
Column('name', String(20)),)engine = create_engine("mysql+mysqldb://root:123@127.0.0.1:3306/s11", max_overflow=5)metadata.create_all(engine)3、多对多查询& & &想要操作多对多，就要有第三张表的介入。& &&& & &流程如图：& & &&&&& 数据库展示：&&######## 多表查询 ###########from sqlalchemy import create_enginefrom sqlalchemy.ext.declarative import declarative_basefrom sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Indexfrom sqlalchemy.orm import sessionmaker, relationshipengine = create_engine("mysql+pymysql://root:123qwe@192.168.1.100:3306/day13", max_overflow=5)Base = declarative_base()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='1.1.1.1'),
Host(hostname='c2',port='22',ip='1.1.1.2'),
Host(hostname='c3',port='22',ip='1.1.1.3'),
Host(hostname='c4',port='22',ip='1.1.1.4'),
Host(hostname='c5',port='22',ip='1.1.1.5'),])mit()session.add_all([
HostUser(username='root'),
HostUser(username='db'),
HostUser(username='nb'),
HostUser(username='sb'),])mit()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),])mit() #生成数据按钮'''Session=sessionmaker(bind=engine)session=Session()#&&&需求来了, 获取c1主机中所有的用户??1、使用【原始方式】获取 。host_obj=session.query(Host).filter(Host.hostname == 'c1').first()print(host_obj.nid) #第一步要找的唯一的【主机的ID】。#得到了结果 ———&ID为1的值。2、在第三张关系表中--& 利用【主机host的ID】找到了所有的对应的【用户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)
#在关系表中拿到了C1【主机的ID】对应的 【全部用户ID】。#执行结果：————& [(1,),(2,),(3),]的列表。3、根据【用户user的ID】找到所有用户。r=zip(*host_2_host_user)# print(list(r)[0])
#目的：转换 [(1,),(2,),(3),] ---&为[1,2,3]# [1,2,3]users=session.query(HostUser.username).filter(HostUser.nid.in_(list(r)[0])).all()print(users)#执行结果：#[('root',), ('db',), ('nb',)]########################################以上的查询方法太low了，其实可以一句话进行才查找。多表查询（三）、############## 多表查询【高逼格】方法 ###################from sqlalchemy import create_enginefrom sqlalchemy.ext.declarative import declarative_basefrom sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Indexfrom sqlalchemy.orm import sessionmaker, relationshipengine = create_engine("mysql+pymysql://root:123qwe@192.168.1.100:3306/day13", max_overflow=5)Base = declarative_base()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'))
host = relationship('Host',backref='h')
host_user = relationship('HostUser',backref='u')Session=sessionmaker(bind=engine)session=Session()########查询结果#######：host_obj = session.query(Host).filter(Host.hostname == 'c1').first()print(host_obj)print(host_obj.nid)print(host_obj.hostname)print('=========================','\n')print(host_obj.h) #第三张表对应的对象。print('=========================','\n')for item in host_obj.h:
print(item.host_user,item.host_user.nid,item.host_user.username)执行结果：&__main__.Host object at 0xFC99B70&1c1=========================[&__main__.HostToHostUser object at 0xFC99828&, &__main__.HostToHostUser object at 0xFC99EB8&, &__main__.HostToHostUser object at 0xFC99F28&]=========================&__main__.HostUser object at 0xFCAE4E0& 1 root&__main__.HostUser object at 0xFC64C50& 2 db&__main__.HostUser object at 0xFC99080& 3 nb4、更简单的方式：多对多查询& & & A && & & ＡＢ　＝＝》关系表 &foreign 和 relationship& & & B & &from sqlalchemy import create_enginefrom sqlalchemy.ext.declarative import declarative_basefrom sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Indexfrom sqlalchemy.orm import sessionmaker, relationshipengine = create_engine("mysql+pymysql://root:123qwe@192.168.1.100:3306/day13", max_overflow=5)Base = declarative_base()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'))
host = relationship('Host',backref='h')
host_user = relationship('HostUser',backref='u')Session=sessionmaker(bind=engine)session=Session()host_obj = session.query(Host).filter(Host.hostname == 'c1').first()print(host_obj)print(host_obj.nid)print('==============================')print(host_obj.h) #第三张表对应的对象。print('===============================','\n')for item in host_obj.h:
print(item.host_user,item.host_user.nid,item.host_user.username)执行结果：&__main__.Host object at 0x000001FDBBA4E630&1==============================[&__main__.HostToHostUser object at 0x000001FDBBA4E2B0&, &__main__.HostToHostUser object at 0x000001FDBBA4E940&, &__main__.HostToHostUser object at 0x000001FDBBA4E9B0&]=============================== &__main__.HostUser object at 0x000001FDBBA6C048& 1 root&__main__.HostUser object at 0x000001FDBBA6C208& 2 db&__main__.HostUser object at 0x000001FDBBA6C3C8& 3 nb5、更更 简单的方式：多对多查询& & & A & & &&＝＝》foreign&和&relationship& & & ＡＢ关系表　只需要进行简单的定义。& & & B & &from sqlalchemy import create_enginefrom sqlalchemy.ext.declarative import declarative_basefrom sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Indexfrom sqlalchemy.orm import sessionmaker, relationshipengine = create_engine("mysql+pymysql://root:123qwe@192.168.1.100:3306/day13", max_overflow=5)Base = declarative_base()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=lambda :HostToHostUser.__table__,backref='h')
# 如果 有lambda的话，则可以关系对应表可以不用 放在上面，可以自由放置。放下面就会报错的;无lambda 的话 ，关系对应表应该放在上面。
无lambda 的话 ，关系对应表应该放在上面。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'))Session=sessionmaker(bind=engine)session=Session()host_obj = session.query(Host).filter(Host.hostname == 'c1').first()print(host_obj)print(host_obj.nid)print('==============================')print(host_obj.host_user)# print(host_obj.h) #第三张表对应的对象。print('===============================')for item in host_obj.host_user:
print(item.username)执行结果：&__main__.Host object at 0xB8F860&1==============================[&__main__.HostUser object at 0xB8F550&, &__main__.HostUser object at 0xB8F518&, &__main__.HostUser object at 0xB8F7B8&]===============================rootdbnb
阅读(...) 评论()