flask-sqlalchemy不同的关系的实例

最新推荐文章于 2020-04-25 12:38:32 发布
最新推荐文章于 2020-04-25 12:38:32 发布
阅读量752 收藏
点赞数
分类专栏： 其他 文章标签： sqlalchemy
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ljhandlwt/article/details/50688183
版权

PS:

1.实例包括一对一,一对多,多对多,以及自身的一对一,一对多,多对多

2.关于表的名字:__tablename__是表的名字,但是我们可以不设置,这样sqlalchemy会根据类名给予默认名,类名的大写字母在表名会变成下划线+小写字母(开头大写则,没有下划线),如WeChat类的默认表名是we_chat.但如果类名全是大写,则表名会和类名一样,像QQ类的默认表名就是QQ

3.实现多对多的关系需要中介表(类似图论里的边的含义),有一点注意的是中介类要写在那两个类之前,否则报错


一对一

微信和QQ的绑定是一对一的关系

一个微信只能绑定一个QQ

一个QQ只能绑定一个微信


class WeChat(db.Model):
        id=db.Column(db.Integer,primary_key=True)
        nickname=db.Column(db.String(80))
        password=db.Column(db.String(120))
        bing_qq=db.relationship('QQ',backref='bing_wechat',uselist=False)

class QQ(db.Model):
        id=db.Column(db.Integer,primary_key=True)
        nickname=db.Column(db.String(80))
        password=db.Column(db.String(120))
        wechat_id=db.Column(db.Integer,db.ForeignKey('we_chat.id'))


relationship和对方的id可以调转写


class WeChat(db.Model):
        id=db.Column(db.Integer,primary_key=True)
        nickname=db.Column(db.String(80))
        password=db.Column(db.String(120))
        qq_id=db.Column(db.Integer,db.ForeignKey('QQ.id'))

class QQ(db.Model):
        id=db.Column(db.Integer,primary_key=True)
        nickname=db.Column(db.String(80))
        password=db.Column(db.String(120))
        bing_wechat=db.relationship('WeChat',backref='bing_qq',uselist=False)


样例
>>> q1=QQ(nickname='123',password='123456')
>>> w1=WeChat(nickname='jh',password='123456')
>>> q1.bing_wechat=w1
>>> db.session.add(q1)
>>> db.session.add(w1)
>>> db.session.commit()
>>> q1.bing_wechat.nickname
u'jh'
>>> w1.bing_qq.nickname
u'123'

>>>


一对多

博客用户和博文是一对多的关系

一个用户有多篇博文,而一篇博文只能有一个作者


class User(db.Model):
        id=db.Column(db.Integer,primary_key=True) 
        nickname=db.Column(db.String(80),unique=True)
        password=db.Column(db.String(120))
        posts=db.relationship('Post',backref='author',lazy='dynamic')

class Post(db.Model):
        id=db.Column(db.Integer,primary_key=True)
        title=db.Column(db.String(120),unique=True)
        body=db.Column(db.Text)
        user_id=db.Column(db.Integer,db.ForeignKey('user.id'))


relationship也可以写在post处


class User(db.Model):
        id=db.Column(db.Integer,primary_key=True) 
        nickname=db.Column(db.String(80),unique=True)
        password=db.Column(db.String(120))

class Post(db.Model):
        id=db.Column(db.Integer,primary_key=True)
        title=db.Column(db.String(120),unique=True)
        body=db.Column(db.Text)
        user_id=db.Column(db.Integer,db.ForeignKey('user.id'))
        author=db.relationship('User',backref='posts')


样例
>>> u1=User(nickname='jh',password='123456')
>>> p1=Post(title='first',body='helloworld',author=u1)
>>> p2=Post(title='second',body='hello,JH',author=u1)
>>> db.session.add(u1)
>>> db.session.add(p1)
>>> db.session.add(p2)
>>> db.session.commit()
>>> u1.posts[0].title
u'first'
>>> u1.posts[1].title
u'second'
>>> for p in u1.posts:
...     print p.title,p.body
...
first helloworld
second hello,JH
>>> p1.author.nickname
u'jh'
>>> p2.author.nickname
u'jh'

>>>


多对多

标签与博文之间的关系是多对多的关系

一个标签可以贴多篇博文

一篇博文也可以贴多个标签


#中介

post_tag=db.Table('post_tag',
db.Column('tag_id',db.Integer,db.ForeignKey('tag.id')),
db.Column('post_id',db.Integer,db.ForeignKey('post.id')))

class Post(db.Model):
        id=db.Column(db.Integer,primary_key=True)
        title=db.Column(db.String(120),unique=True)
        body=db.Column(db.Text)
        tags=db.relationship('Tag',secondary=post_tag,backref='posts',lazy='dynamic')

class Tag(db.Model):
        id=db.Column(db.Integer,primary_key=True)
        name=db.Column(db.String(120),unique=True)


同样,relationship写在哪里都没所谓


post_tag=db.Table('post_tag',
db.Column('tag_id',db.Integer,db.ForeignKey('tag.id')),
db.Column('post_id',db.Integer,db.ForeignKey('post.id')))

class Post(db.Model):
        id=db.Column(db.Integer,primary_key=True)
        title=db.Column(db.String(120),unique=True)
        body=db.Column(db.Text)

class Tag(db.Model):
        id=db.Column(db.Integer,primary_key=True)
        name=db.Column(db.String(120),unique=True)
        posts=db.relationship('Post',secondary=post_tag,backref='tags',lazy='dynamic')


样例

>>> t1=Tag(name='python')
>>> t2=Tag(name='sqlalchemy')
>>> p1=Post(title='str in python',body='...')
>>> p2=Post(title='many to many in flask-sqlalchemy',body='...')
>>> t1.posts.append(p1)
>>> t1.posts.append(p2)
>>> p2.tags.append(t2)
>>> db.session.add(t1)
>>> db.session.add(t2)
>>> db.session.add(p1)
>>> db.session.add(p2)
>>> db.session.commit()
>>> for p in t1.posts:
...     print p.title
...
many to many in flask-sqlalchemy
str in python
>>> for p in t2.posts:
...     print p.title
...
many to many in flask-sqlalchemy
>>> for t in p1.tags:
...     print t.name
...
python
>>> for t in p2.tags:
...     print t.name
...
python
sqlalchemy

>>>


自身一对一

链表中的结点间是自身一对一的关系

一个结点的next是另一个结点,prev则是又另外一个结点


class Node(db.Model):
        id=db.Column(db.Integer,primary_key=True)
        val=db.Column(db.Integer)
        next_id=db.Column(db.Integer,db.ForeignKey('node.id'))
        next=db.relationship('Node',uselist=False,remote_side=[id],backref=db.backref('prev',uselist=False))


样例

>>> n1=Node(val=1)
>>> n2=Node(val=2)
>>> n3=Node(val=3)
>>> n1.next=n2
>>> n3.prev=n2
>>> db.session.add(n1)
>>> db.session.add(n2)
>>> db.session.add(n3)
>>> db.session.commit()
>>> n1.next.val
2
>>> n2.prev.val
1
>>> n2.next.val
3
>>> n3.prev.val
2

>>>


自身一对多

父亲与孩子的关系是自身一对多的关系

一个父亲可以有多个孩子

但一个孩子只会有一个父亲


class People(db.Model):
        id=db.Column(db.Integer,primary_key=True)
        name=db.Column(db.String(40))
        father_id=db.Column(db.Integer,db.ForeignKey('people.id'))
        father=db.relationship('People',uselist=False,remote_side=[id],backref='sons')


样例

>>> pf=People(name='jh')
>>> p1=People(name='j1')
>>> p2=People(name='j2')
>>> pf.sons.append(p1)
>>> p2.father=pf
>>> db.session.add(p1)
>>> db.session.add(p2)
>>> db.session.add(pf)
>>> db.session.commit()
>>> for p in pf.sons:
...     print p.name
...
j1
j2
>>> p1.father.name
u'jh'
>>> p2.father.name
u'jh'

>>>


自身多对多

微博中用户关注和被关注是自身多对多的关系

每个用户可以关注多个用户,而他也能被多个用户关注


#中介

user_user=db.Table('user_user',
db.Column('user1_id',db.Integer,db.ForeignKey('user.id'),primary_key=True),

db.Column('user2_id',db.Integer,db.ForeignKey('user.id'),primary_key=True))


class User(db.Model):
        id=db.Column(db.Integer,primary_key=True)
        nickname=db.Column(db.String(80),unique=True)
        password=db.Column(db.String(120))

        concern=db.relationship('User',secondary=user_user,primaryjoin=id==user_user.c.user1_id,
        secondaryjoin=id==user_user.c.user2_id,backref='concerned')

        def __repr__(self):
                return '<'+self.nickname+'>'#这里方便下面的查看


样例
>>> u1=User(nickname='j1',password='123456')
>>> u2=User(nickname='j2',password='123456')
>>> u3=User(nickname='j3',password='123456')
>>> u4=User(nickname='j4',password='123456')
>>> db.session.add(u1)
>>> db.session.add(u2)
>>> db.session.add(u3)
>>> db.session.add(u4)
>>> u1.concern.append(u2)
>>> u2.concern.append(u3)
>>> u2.concern.append(u4)
>>> u3.concern.append(u2)
>>> u4.concern.append(u1)
>>> db.session.commit()
>>> u1.concern
[<j2>]
>>> u1.concerned
[<j4>]
>>> u2.concern
[<j3>, <j4>]
>>> u2.concerned
[<j1>, <j3>]
>>> u3.concern
[<j2>]
>>> u3.concerned
[<j2>]
>>> u4.concern
[<j1>]
>>> u4.concerned
[<j2>]
>>>
ljhandlwt
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入浅出Flask(46)：flask_sqlalchemy的简单关系
大坡3D软件开发
08-31 161
我们知道使用关系的数据库，最大的优点就是关系的维护。如果不使用关系，就跟保存文件是差不多的。既然我们都使用关系的数据库，就需要利用好关系，因为关系的存在是相互约束和追溯。比如创建一个论坛程序，需要对论坛发表的文章进行归类，放到不同的板块去。所以文章与归类之间就有一个关系了，所有文章必须存在于一个归类之中。我们就使用数据库来保存这种关系，并且维护这种关系。不会出现发表的文章不出现在分类之中，关系数据库已经帮助检查。为了学习db.relationship的作用，我们一步一步地通过例子演示。 首先来创建两个
Flask-SQLAlchemy 数据模型之间的关系
qq_30507163的博客
12-04 299
一对多 先建立一个数据模型，用来表示测试系统的测试用例: class TestCase(db.Model): __name__ = 'test_case' id = db.Column(db.Intager(), primary_key=True) case_id = db.Column(db.Sting(128), nullable=False, comment=...
Flask-sqlalchemy模型之间的关联
登高自卑
02-09 1046
仅仅是为了方便查询需要一些属性去便利的查询数据但这些数据不能出现在表的字段中 一对多 #在一的一方写关联 users = relationship('User',backref=role) #参数为模型名,关系的另一个模型的反向引用，User表明与User模型发生了关联,backref表明role是User要用的属性 效果 完整代码 from flask import Flask from f...
Flask sqlalchemy 一对多的关系数据
weixin_38202526的博客
09-22 600
前几天已经讲了flask sqlalchemy的创建方法，以及最基本的用法，今天来说一下一对多的关系 为了方便测试，使用的是上次修改的代码，本次演示的是course和student的关系，一个course可以对应多个student from config import db class Student(db.Model): __tablename__ = 'student' ...
flask-sqlalchemy 一对多关系
hehekk的博客
08-29 1286
在flask-sqlalchemy一对多关系中，在多的一方定义外键，关系可在任一方定义 class User(db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(10)) posts = db...
Flask-SQLAlchemy-2.3.2.tar.gz
12-21
**Flask-SQLAlchemy**是基于流行的Web开发框架**Flask**的一个扩展，它将强大的对象关系映射（ORM）库**SQLAlchemy**与Flask相结合，为Python开发者提供了便捷的数据库操作支持。在Flask应用中集成SQLAlchemy，可以...
Flask-SQLAlchemy-Example:使用 Flask 和 SqlAlchemy 的示例货物管理网页
05-30
在本项目中，"Flask-SQLAlchemy-Example" 是一个使用 Flask 框架和 SQLAlchemy ORM（对象关系映射）构建的货物管理系统的实例。Flask 是一个轻量级的 Python Web 开发框架，而 SQLAlchemy 则是 Python 中流行的...
flask-sqlalchemy-stubs:测试flask-sqlalchemy的存根和mypy插件
05-25
[mypy]plugins = flasksqlamypy实例from typing import TYPE_CHECKINGfrom flask_sqlalchemy import SQLAlchemydb = SQLAlchemy()if TYPE_CHECKING: from flask_sqlalchemy.model import Model BaseModel = db.make...
Python使用Flask-SQLAlchemy连接数据库操作示例
09-20
主要介绍了Python使用Flask-SQLAlchemy连接数据库操作,简单介绍了flask、Mysql-Python以及Flask-SQLAlchemy的安装方法,并结合实例形式分析了基于Flask-SQLAlchemy的数据库连接相关操作技巧,需要的朋友可以参考下
flask-SQLAlchemy
07-24
**Flask-SQLAlchemy** 是一个基于 Flask 微框架的扩展，它为 Flask 提供了对 SQLAlchemy 的集成，使得在 Flask 应用中使用 ORM（对象关系映射）进行数据库操作变得简单易行。SQLAlchemy 是 Python 中广泛使用的 ORM ...
Flask-SQLalchemy常见关系模板
年华终归属时光的博客
09-10 316
常见关系模板代码 以下罗列了使用关系型数据库中常见关系定义模板代码 一对多 示例场景： 用户与其发布的帖子(用户表与帖子表) 角色与所属于该角色的用户(角色表与多用户表) 示例代码 class Role(db.Model):     """角色表"""     __tablename__ = 'roles'     id = db.Column(db.Integer, primary_k...
SQLAlchemy之relationship之remote_side
LYLLOAD的专栏
08-23 3021
需要给每个user添加一个leader, 于是在user表里添加leader, 而leader也是一个user, 于是构成了自引用。 1 2 3 4 5 6 7 8 9 10 11 class User(db.Model): __tablename__ = 'users' id = db.Column(Integer, primary_key=...
Flask SQLAlchemy定义表之间关系（详解）
qq_38796548的博客
04-25 2211
1.定义关系 在关系型数据库中，定义表与表之间的联系需要两步：第一步是创建外键，外键是用来在A表存放B表的主键值以便和B表建立联系的字段，并且外键只能存放单一数据（标量），总是在“多”这一侧定义；第二步是创建关系属性，使用关系函数进行在更复杂的多对多关系中，还需要建立第三方关键表来管理关系。下面将介绍一对多、多对一、一对一、多对多关系的原理及实际操作。 2.一对多、多对一 一对多关系可用作者和文章...
12.1 高级多对多关系
sinat_34927324的博客
04-22 471
一. 一对多关系    我们前面讲了两个一对多关系：角色和它所对应的用户， 用户和它所对应的文章， 在一对多关系中， 我们在‘一’的这边设置db.relationship， 在‘多’的一边设置一个外键。二. 多对多关系    而数据库除了一对多关系之外还有多对多关系。最常见的是学生选课这个多对多关系， 一个学生可以选择多门课程， 一门课程也可以被多个学生选择， 如果我们在学生这边添加外键显然行不通...
flask-SQLAlchemy一些使用技巧（关联关系的创建）
zengchenacmer的专栏
07-22 8862
flask-SQLAlchemy 直接使用了SQLAlchemy，只不过是把SQLAlchemy的功能减少了很大一部分，只支持其中很少的一部分功能，因此，在使用falsk-SQLAlchemy，可以结合SQLAlchemy中的功能一起使用。这里主要讲两个数据库之间关联关系的创建，以及之间在这种关系之下的 add、查询等操作1、建立关联关系class Role(db.Model): __tab
使用flask-sqlalchemy创建一对多的关系表
水痕
03-15 3762
本案例中是一个用户注册的案例，其中涉及到兴趣爱好这个复选框的，处理方式就是创建一个兴趣爱好表，使用户表(一)对兴趣爱好表(多)的方式存储 index.html代码 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>用户注册</title> <link rel="stylesheet"
Flask-sqlalchemy外键关系映射
Co_zy的博客
09-28 9017
本文中,为了测试方便,所以使用sqlite,定义两张表User Article Article中author_id引用User表中的id,也就是author_id作为User表中id的外键from flask import Flask from flask_sqlalchemy import SQLAlchemyapp = Flask(__name__) app.config['SQLALCHE
flask-sqlalchemy 使用详解
热门推荐
阿汤哥
06-29 1万+
      之前我们讲了许多关于sqlalchemy的文章，今天就为大家讲讲flask_sqlalchemy的使用！在使用flask_sqlalchemy之前，请确保安装了flask_sqlalchemy,安装代码： pip install flask_sqlalchemy 　　flask_sqlalchemy用法与sqlalchemy类似，两者主要区别是sqlalchemy独立于flask...
Flask-sqlalchemy多对多关系
Co_zy的博客
10-01 4241
from flask import Flask from flask_sqlalchemy import SQLAlchemyapp = Flask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///./Article2.db' db = SQLAlchemy(app)article_tag = db.Table('articl
flask 1.1.4 怎么使用 flask-sqlalchemy
最新发布
05-20
在以上代码中，我们首先导入 Flask 和 SQLAlchemy，然后创建 Flask 应用程序实例和一个 SQLAlchemy 实例。在 SQLAlchemy 实例中，我们将 SQLite 数据库的 URI 配置为 'sqlite:///example.db'。 接下来，我们可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值