在SQLAlchemy中使用数据库外键约束

最新推荐文章于 2024-09-27 15:46:13 发布
最新推荐文章于 2024-09-27 15:46:13 发布
阅读量912 收藏 4
点赞数
文章标签： python mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42763269/article/details/112588764
版权

1.SQLAlchemy外键及其约束

  • 外键可以使得几张表格之间联系更加紧密
from sqlalchemy import create_engine, and_, or_
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, DECIMAL, Boolean, Enum, DATE, DATETIME, Time, Text, ForeignKey
from sqlalchemy.dialects.mysql import LONGTEXT
from sqlalchemy.orm import sessionmaker
from datetime import datetime
import random
from sqlalchemy import func

HOSTNAME = '127.0.0.1'
DATABASE = 'flask_orm'
PORT = 3306
USERNAME = 'root'
PASSWORD = 'root'

DB_URL = 'mysql+pymysql://{}:{}@{}:{}/{}'.format(USERNAME, PASSWORD, HOSTNAME, PORT, DATABASE)

engine = create_engine(DB_URL)
Base = declarative_base(engine)


class User(Base):
    __tablename__ = 'users'

    id = Column(Integer, primary_key=True, autoincrement=True)
    name = Column(String(50))

    def __str__(self):
        return 'User(name:{})'.format(self.name)


class Book(Base):
    __tablename__ = 'books'

    id = Column(Integer, primary_key=True, autoincrement=True)
    title = Column(String(50), nullable=False)
    content = Column(Text, nullable=False)
    uid = Column(Integer, ForeignKey('users.id', ondelete='RESTRICT'))


# Base.metadata.drop_all()
# Base.metadata.create_all()
Session = sessionmaker(bind=engine)
session = Session()

user = User(name='吴承恩')
session.add(user)
session.commit()

book = Book(title='西游记', content='三打白骨精', uid=1)
session.add(book)
session.commit()

# 外键的查询
# book1 = session.query(Book).first()
# id = book1.uid
# user = session.query(User).get(id)
# print(user)

user = session.query(User).filter(User.id == Book.uid).first()
print(user)

#外键的几种约束
RESTRICT：引用的父表被删除，将会阻止删除
NO ACTION：等同于RESTRICT
CASCADE：同时一起删除
SET NULL：父表可以被删除，子表数据设置为null

表与表之间的关系：

  • 一对多：
from sqlalchemy import create_engine, and_, or_
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, DECIMAL, Boolean, Enum, DATE, DATETIME, Time, Text, ForeignKey
from sqlalchemy.dialects.mysql import LONGTEXT
from sqlalchemy.orm import sessionmaker, relationship
from datetime import datetime
import random
from sqlalchemy import func

HOSTNAME = '127.0.0.1'
DATABASE = 'flask_orm'
PORT = 3306
USERNAME = 'root'
PASSWORD = 'root'

DB_URL = 'mysql+pymysql://{}:{}@{}:{}/{}'.format(USERNAME, PASSWORD, HOSTNAME, PORT, DATABASE)

engine = create_engine(DB_URL)
Base = declarative_base(engine)


class User(Base):
    __tablename__ = 'users'

    id = Column(Integer, primary_key=True, autoincrement=True)
    name = Column(String(50))

    book = relationship('Book')

    def __str__(self):
        return 'User(name:{})'.format(self.name)


class Book(Base):
    __tablename__ = 'books'

    id = Column(Integer, primary_key=True, autoincrement=True)
    title = Column(String(50), nullable=False)
    content = Column(Text, nullable=False)
    uid = Column(Integer, ForeignKey('users.id', ondelete='RESTRICT'))
    author = relationship('User')#加上这句话才能构成表与表之间的联系

    def __str__(self):
        return 'Book(title:{})'.format(self.title)

# Base.metadata.drop_all()
# Base.metadata.create_all()
Session = sessionmaker(bind=engine)
session = Session()

# user = session.query(Book).first()
# print(user.uid)
#
# u = session.query(User).filter(Book.id == user.uid).first()
# print(u)

# data = session.query(Book).first()
# print(data.author)

# data = session.query(User).first()
# print(data.book)  # 一对多，输出的是列表[<__main__.Book object at 0x000002802D94C4C8>, <__main__.Book object at 0x000002802D94C648>]
# for i in data.book:
#     print(i)

user = User(name='施耐庵')

book = Book(title='水浒传',content='saf')
book2 = Book(title='笑傲江湖', content='令狐冲')

book.author = user
book2.author = user

session.add_all([book,book2])
session.commit()
  • 一对一：就是特殊的一对多，只需要在addresses = relationship(“Address”, backref=‘addresses’, uselist=False)在里边加上uselist=False即可
from sqlalchemy import create_engine, and_, or_
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, DECIMAL, Boolean, Enum, DATE, DATETIME, Time, Text, ForeignKey
from sqlalchemy.dialects.mysql import LONGTEXT
from sqlalchemy.orm import sessionmaker, relationship
from datetime import datetime
import random
from sqlalchemy import func

HOSTNAME = '127.0.0.1'
DATABASE = 'flask_orm'
PORT = 3306
USERNAME = 'root'
PASSWORD = 'root'

DB_URL = 'mysql+pymysql://{}:{}@{}:{}/{}'.format(USERNAME, PASSWORD, HOSTNAME, PORT, DATABASE)

engine = create_engine(DB_URL)
Base = declarative_base(engine)


class User(Base):
    __tablename__ = 'user'
    id = Column(Integer, primary_key=True)
    name = Column(String(50))
    fullname = Column(String(50))
    password = Column(String(100))

    addresses = relationship("Address", backref='addresses', uselist=False)#backref加上去就不用在其他表里添加。这个表示反向联系


class Address(Base):
    __tablename__ = 'addresses'
    id = Column(Integer, primary_key=True)
    email_address = Column(String(50))
    user_id = Column(Integer, ForeignKey('user.id'))
    # user = relationship('Address', backref='user')

Base.metadata.drop_all()
Base.metadata.create_all()
Session = sessionmaker(bind=engine)
session = Session()

user = User(name='duke', fullname='dk', password='123')
address = Address(email_address='xxxx.com')

user.addresses = address
session.add(user)
session.commit()
  • 多对多：创建这种类型的关系表需要建立一个中间表，导入table模块
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String ForeignKey
from sqlalchemy.orm import sessionmaker, relationship, backref
from sqlalchemy import func
from sqlalchemy import Table

HOSTNAME = '127.0.0.1'
DATABASE = 'flask_orm'
PORT = 3306
USERNAME = 'root'
PASSWORD = 'root'

DB_URL = 'mysql+pymysql://{}:{}@{}:{}/{}'.format(USERNAME, PASSWORD, HOSTNAME, PORT, DATABASE)

engine = create_engine(DB_URL)
Base = declarative_base(engine)

# 创建中间表格,是为了保存两个表格的外键
teacher_classes = Table(
    'teacher_classes',
    Base.metadata,
    Column('teacher_id', Integer, ForeignKey('teacher.id')),
    Column('classes_id', Integer, ForeignKey('classes.id')),
)
# 中间表第一个参数表示它的表名，第二个参数是base基类的类，第三第四个参数表示要连接的两个表

class Teacher(Base):
    __tablename__ = 'teacher'

    id = Column(Integer, primary_key=True, autoincrement=True)
    name = Column(String(50))

    classes = relationship('Classes', backref='teachers', secondary=teacher_classes)

    def __str__(self):
        return 'Teacher(name:{})'.format(self.name)

class Classes(Base):
    __tablename__ = 'classes'

    id = Column(Integer, primary_key=True, autoincrement=True)
    name = Column(String(50))

    def __str__(self):
        return 'Classes(name:{})'.format(self.name)

# Base.metadata.drop_all()
# Base.metadata.create_all()
Session = sessionmaker(bind=engine)
session = Session()

# teacher1 = Teacher(name='lihua')
# teacher2 = Teacher(name='duke')

# class1 = Classes(name='一班')
# class2 = Classes(name='二班')
#
# teacher1.classes.append(class1)
# teacher1.classes.append(class2)
#
# teacher2.classes.append(class1)
# teacher2.classes.append(class2)
#
# session.add_all([teacher1, teacher2])
# session.commit()

# 根据老师查班级
teacher = session.query(Teacher).first()
print(teacher)
for i in teacher.classes:
    print(i)

# 根据班级查老师
class1 = session.query(Classes).first()
print(class1)
for i in class1.teachers:
    print(i)

2.排序和查询高级order_by

排序

order_by：根据指定的字段进行排序，默认是升序排序，若在前面加上-表示降序排序

#默认是升序
article = session.query(Article).order_by(Article.id).all()
#倒序查询(-Article.id)或者调用desc()
article = session.query(Article).order_by(Article.id.desc()).all()
article = session.query(Article).order_by(-Article.id).all()

order_by也可以在模型中定义：

 __mapper_args__ = {
     "order_by": title
 }
 表示按照title字段进行排序。

代码示例：

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

HOSTNAME = '127.0.0.1'
DATABASE = 'flask_orm'
PORT = 3306
USERNAME = 'root'
PASSWORD = 'root'

DB_URL = 'mysql+pymysql://{}:{}@{}:{}/{}'.format(USERNAME, PASSWORD, HOSTNAME, PORT, DATABASE)

engine = create_engine(DB_URL)
Base = declarative_base(engine)


class Article(Base):
    __tablename__ = 'article'

    id = Column(Integer, primary_key=True, autoincrement=True)
    title = Column(String(50))

#该方法可以直接在模型中定义默认的排序
    __mapper_args__ = {
        'order_by':id
    }
    def __str__(self):
        return 'Article(title:%s)'% self.title

# Base.metadata.drop_all()
# Base.metadata.create_all()
Session = sessionmaker(bind=engine)
session = Session()

# for i in range(6):
#     article = Article(title='文章%s'%i)
#     session.add(article)
#
# session.commit()

#默认是升序
# article = session.query(Article).order_by(Article.id).all()
#倒序查询
# article = session.query(Article).order_by(Article.id.desc()).all()
# for item in article:
#     print(item)

# limit 限制查询条数
# article = session.query(Article).limit(3).all()

# offset 从哪条开始查询
# article = session.query(Article).offset(2).limit(3).all()

# 切片,把所有的数据全部取出来再显示出来
article = session.query(Article).all()[2:5]
for item in article:
    print(item)
  • 高级查询
  1. group_by:根据某个字段进行分组
result = session.query(User.gender, func.count(User.id)).group_by(User.gender).all()
  1. having:进一步过滤查找结果
result = session.query(User.age, func.count(User.age)).group_by(User.age).having(User.age<25).having(User.age>19).all()
  1. join方法：分为inner join 以及outer join。默认的是inner join，而left join和right join都是outer join。
for u,a in session.query(User,Address).filter(User.id==Address.user_id).all():
    print(u)
    print(a)

而outer join默认为左外查询

for instance in session.query(User,Address).outerjoin(Address).all():
	print(instance)
  • 别名：用于多表查询时重复使用一个表。
from sqlalchemy.orm import aliased
adalias1 = aliased(Address)
adalias2 = aliased(Address)
for username,email1,email2 in session.query(User.name,adalias1.email_address,adalias2.email_address).join(adalias1).join(adalias2).all():
    print(username,email1,email2)
  • 子查询：可以在已经查询的数据里再次查询其他数据
from sqlalchemy import create_engine, and_, or_
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, DECIMAL, Boolean, Enum, DateTime, TEXT, ForeignKey
from sqlalchemy.dialects.mysql import LONGTEXT
from sqlalchemy.orm import sessionmaker, relationship
from datetime import datetime
from sqlalchemy import func
import random
from sqlalchemy import Table

HOSTNAME = '127.0.0.1'
DATABASE = 'class'
PORT = 3306
USERNAME = 'root'
PASSWORD = 'root'

DB_URL = 'mysql+pymysql://{}:{}@{}:{}/{}'.format(USERNAME, PASSWORD, HOSTNAME, PORT, DATABASE)

engine = create_engine(DB_URL)
Base = declarative_base(engine)


class User(Base):
    __tablename__ = 'user2'

    id = Column(Integer, primary_key=True, autoincrement=True)
    name = Column(String(50))
    city = Column(String(50))
    age = Column(Integer)

    def __str__(self):
        return 'User(name:%s)' % self.name


# Base.metadata.drop_all()
# Base.metadata.create_all()

Session = sessionmaker(bind=engine)
session = Session()



# 子查询
# user = session.query(User).filter(User.name == '张三').first()
# # print(user)
# data = session.query(User).filter(User.city == user.city, User.age == user.age).all()
# for item in data:
#     print(item)

sub = session.query(User.city.label('city'), User.age.label('age')).filter(User.name == '张三').subquery()
data = session.query(User).filter(User.city == sub.c.city, User.age == sub.c.age).all()
for item in data:
    print(item)
duke-coder
关注
SQLALchemy ORM 的关联关系之表的外键关联
CSDN全栈领域优秀博主，阿里云博客专家，工信部权威认证物联网技术开发工程师，曾30分钟高分通过C语言二级，两天手撸代码完成EasyX飞机大战，靠接软件私活一个月换苹果电脑
08-16 567
在SQLAlchemy ORM中，表的外键关联是通过在模型（类）之间定义关系（relationship）并指定外键列（ForeignKey）来实现的。这种关联允许你在Python代码中以面向对象的方式操作数据库表之间的关系。
SQLAlchemy-外键
baidu_39394442的博客
04-13 1423
1.0 外键约束 1.1介绍 在Mysql中，外键可以让表之间的关系更亲密，而sqlaichemy也是支持外键的, 它通过ForeignKey类 来实现的，并可以指定表的外键约束。 class Base_key1(Bill): __tablename__ = 'class_key1' #创建数据库表 id = Column(Integer, primary_key=True, autoincrement=True) name = Column(String(50)) de
Sqlalchemy - 外键约束（relationship）
⚡
07-19 2353
student2school = relationship("类名",backref = "student2school") backref: back reference(反向调用) 建表： from sqlalchemy.ext.declarative import declarative_base from sqlalchemy import Column,Integer,S...
SQLAlchemy 中的通用外键 (类似于 Django ORM)
最新发布
D0126_的博客
09-27 265
在 SQLAlchemy 中，我们经常需要为不同的模型添加评论功能，例如：文章、项目、职位等。如果我们为每个模型分别创建自己的评论模型，那么就会产生大量重复的代码。为了解决这个问题，我们可以使用通用外键 (Generic Foreign Key) 来实现。来实现通用外键，它允许一个模型的外键字段可以指向不同的模型。这样，就可以实现一个评论可以与多个模型关联。当然，你也可以根据需要修改代码来实现其他功能，例如：查询一个模型的所有评论等。这三种方法各有优缺点，开发者可以根据自己的需求选择合适的方法。
SQLAlchemy —— 外键及其约束
白菜执笔人的博客
04-25 865
Flask 学习笔记 一、外键        
SQLAlchemy外键约束
sweet的博客
05-02 1039
在创建一个模型的时候，一旦生成一个表，就无法在模型中添加属性，此时的解决办法是，先在数据库中删除这张表drop tables article;。然后重新运行。 1.外键： class User(db.Model): __tablename__ = 'user' id = db.Column(db.Integer,primary_key=True,autoincrement=...
SQLALchemy之外键
why404
01-22 4754
表关系 表之间的关系存在三种：一对一、一对多、多对多。 而SQLAlchemy中的ORM也可以模拟这三种关系。 一对一其实在SQLAlchemy中底层是通过一对多的方式模拟的。 SQLAlchemy创建外键 在从表中增加一个字段，指定这个字段外键的是哪个表的哪个字段就可以了。 从表中外键的字段，必须和主表的主键字段类型保持一致。 # 主表(user) / 从表(news) class Us...
SQLAlchemy如何手动设置外键约束？
08-24
在SQLAlchemy中，要手动设置外键约束，你可以使用`ForeignKey`类定义两个关联的模型，并确保在创建相关表时它们之间有正确的引用。这里有一个基本示例[^1]： ```python from sqlalchemy import Column, Integer, ...
Flask Web——数据库
fatfairyyy的博客
09-13 538
在以上的数据库表字段定义中，将id定义为数据库类型中的整型，设置。
【Flask数据库】外键及其四种约束讲解
qq_45696681的博客
10-17 631
文章目录外键1、外键约束种类：1）RESTRICT：父表数据被删除，会阻止删除。默认就是这一项。2）NO ACTION：在MySQL中，同RESTRICT。3）CASCADE：级联删除。即父表数据被删除，子表也被删除。4）SET NULL：父表数据被删除，子表数据会设置为NULL。2、选定外键约束的种类，通过设定关键字ondelete的值实现： 外键 通过ForeignKey类来实现，并且可以指定...
十、SQLAlchemy的外键约束
李公子的博客
09-07 219
1.写好配置文件 今天来和大家一块学习下SQLAlchemy的外键约束。我们先添加一个config.py用来写连接MySQL的参数。代码如下。 DIALECT = 'mysql' # 要用的什么数据库 DRIVER = 'pymysql' # 连接数据库驱动 USERNAME = 'root' # 用户名 PASSWORD = 'root' # 密码 HOST = 'localhos...
flask框架学习笔记——SQLAlchemy外键约束
fnms88的博客
11-19 585
from flask import Flask import config from flask_sqlalchemy import SQLAlchemy app = Flask (name) app.config.from_object(config) db=SQLAlchemy(app) class User(db.Model): tablename=‘user’ id=db.Column(d...
sqlalchemy的foreignkey操作
MarryOnlyQueen的博客
10-03 3040
创表操作 create_table_foreignkey.py #一对多建表操作 from sqlalchemy.ext.declarative import declarative_base from sqlalchemy import create_engine from sqlalchemy import Column, Integer, String, ForeignKey from sq...
Python之SQLAlchemy学习--外键约束问题
weixin_34114823的博客
12-09 185
以下问题赞为解决： # class User(Base):# __tablename__ = 'user'# #表的结构# id = Column(String(20), primary_key=True)# username = Column(String(20))# books = relationship('Book')# class Book(B...
SQLAlchemy的使用---外键ForeignKey数据增删改查
weixin_33962923的博客
02-15 2054
SQLAlchemy的使用---外键ForeignKey数据增删改查 # 添加数据 from sqlalchemy.orm import sessionmaker from create_table_ForeignKey import engine, Student, School Session = sessionmaker...
sqlalchemy:外键
fangxiaofei123的博客
04-06 203
数据库连接 from sqlalchemy import create_engine, func 数据表基类 from sqlalchemy.ext.declarative import declarative_base 表格字段类型 from sqlalchemy import Column,String,Integer,DateTime,Enum,Date,Time,or_,Text,Fore...
【SQLAlChemy】表之间的关系，外键如何使用？
weixin_55818116的博客
06-14 818
在SQLAlchemy中如何处理表与表之间的关系，如何处理约束与外键，来看看这篇文章吧。
sqlalchemy 外键
anzhang5248的博客
10-02 174
一、表 from sqlalchemy.orm import relationship from sqlalchemy import Column from sqlalchemy import Integer,String,ForeignKey class Depart(Base): __tablename__ = 'depart' id = Colu...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值