当前位置： 首页 > article >正文

第22篇：Python开发进阶：详解使用SQLAlchemy进行ORM数据库编程技术

article 2025/1/28 11:20:22

第22篇：使用SQLAlchemy进行ORM

内容简介

在现代应用开发中，对象关系映射（ORM，Object-Relational Mapping）是一种将对象编程语言中的对象与关系型数据库中的数据进行映射的技术。SQLAlchemy是Python中功能强大且灵活的ORM框架，广泛用于简化数据库操作。本文将深入探讨ORM的概念，介绍SQLAlchemy的安装与配置，指导如何定义模型，执行CRUD操作，并详细讲解如何在模型之间定义关系。通过理论与实践相结合的方式，您将全面掌握使用SQLAlchemy进行数据库操作的技能。

目录

  1. ORM概述
    • 什么是ORM？
    • ORM的优势
    • 常见的Python ORM框架
  2. SQLAlchemy的安装与配置
    • 安装SQLAlchemy
    • 安装数据库驱动
    • 创建数据库引擎
  3. 定义模型
    • 创建基类
    • 定义模型类
    • 创建数据库表
  4. 执行CRUD操作
    • 创建记录（Create）
    • 读取记录（Read）
    • 更新记录（Update）
    • 删除记录（Delete）
  5. 关系定义
    • 一对多关系
    • 多对多关系
    • 一对一关系
  6. 实践项目：使用SQLAlchemy构建博客系统
    • 项目概述
    • 步骤一：设置数据库
    • 步骤二：定义模型
    • 步骤三：执行CRUD操作
    • 步骤四：定义模型关系
  7. 常见问题及解决方法
    • 问题1：如何处理数据库迁移？
    • 问题2：如何优化查询性能？
    • 问题3：如何处理复杂关系？
  8. 总结

ORM概述

什么是ORM？

**对象关系映射（ORM，Object-Relational Mapping）**是一种编程技术，旨在将面向对象编程语言中的对象与关系型数据库中的数据表进行映射。通过ORM，开发者可以使用面向对象的方式操作数据库，而无需编写大量的SQL语句。

示例：

假设有一个User类和一个users表，ORM允许我们通过操作User对象来增删改查users表中的数据。

ORM的优势

  • 简化代码：减少手写SQL语句，使用面向对象的方式操作数据。
  • 提高生产力：快速开发和迭代，专注于业务逻辑。
  • 数据库无关性：通过配置不同的数据库驱动，轻松切换数据库。
  • 安全性：自动处理参数化查询，防止SQL注入攻击。
  • 维护性：集中管理模型类，代码结构清晰，便于维护和扩展。

常见的Python ORM框架

  • SQLAlchemy：功能强大且灵活，支持多种数据库，适用于复杂项目。
  • Django ORM：集成在Django框架中，适用于快速开发Web应用。
  • Peewee：轻量级ORM，适用于小型项目或嵌入式数据库。
  • Tortoise ORM：支持异步操作，适用于异步Web框架如FastAPI。

SQLAlchemy的安装与配置

安装SQLAlchemy

使用pip安装最新版本的SQLAlchemy：

pip install SQLAlchemy

安装数据库驱动

根据所使用的数据库，安装相应的数据库驱动。例如：

  • MySQL：mysql-connector-python 或 PyMySQL

    pip install mysql-connector-python
# 或
pip install PyMySQL

  • PostgreSQL：psycopg2

    pip install psycopg2

  • SQLite：无需额外安装，Python标准库已内置支持。

创建数据库引擎

数据库引擎是SQLAlchemy与数据库进行通信的接口。通过create_engine函数创建引擎对象。

示例代码：

from sqlalchemy import create_engine

# MySQL连接字符串格式：mysql+mysqlconnector://username:password@host:port/database
DATABASE_URL = "mysql+mysqlconnector://root:your_password@localhost:3306/online_store"

# 创建引擎
engine = create_engine(DATABASE_URL, echo=True)

说明：

  • echo=True：启用SQLAlchemy的日志记录，显示生成的SQL语句，便于调试。
  • 替换username、password、host、port和database为实际的数据库配置。

定义模型

创建基类

使用declarative_base创建基类，所有的模型类都将继承自该基类。

示例代码：

from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

定义模型类

通过继承基类，定义与数据库表对应的模型类。每个模型类的属性对应数据库表的列。

示例代码：

from sqlalchemy import Column, Integer, String, Float, Text, TIMESTAMP, func

class Product(Base):
    __tablename__ = 'products'

    id = Column(Integer, primary_key=True, autoincrement=True)
    name = Column(String(100), nullable=False)
    description = Column(Text)
    price = Column(Float, nullable=False)
    stock = Column(Integer, default=0)
    created_at = Column(TIMESTAMP, server_default=func.now())

    def __repr__(self):
        return f"<Product(name='{self.name}', price={self.price}, stock={self.stock})>"

说明：

  • __tablename__：指定数据库表名。
  • Column：定义表的列及其属性，如数据类型、主键、默认值等。
  • __repr__：定义对象的字符串表示，便于调试和日志记录。

创建数据库表

使用Base.metadata.create_all根据模型定义创建数据库表。

示例代码：

# 创建所有表
Base.metadata.create_all(engine)

说明：

  • 确保在定义所有模型类后调用此方法，以创建相应的数据库表。
  • 如果表已存在，create_all不会重复创建。

执行CRUD操作

创建记录（Create）

通过会话对象添加新记录并提交到数据库。

示例代码：

from sqlalchemy.orm import sessionmaker

# 创建会话
Session = sessionmaker(bind=engine)
session = Session()

# 创建新产品
new_product = Product(name='无线鼠标', description='高精度无线鼠标，舒适手感。', price=49.99, stock=150)
session.add(new_product)
session.commit()

print("新产品已添加:", new_product)

说明：

  • sessionmaker：创建会话工厂，绑定到引擎。
  • session.add：将新对象添加到会话。
  • session.commit：提交事务，将更改保存到数据库。

读取记录（Read）

通过会话对象查询数据库中的记录。

示例代码：

# 查询所有产品
products = session.query(Product).all()
for product in products:
    print(product)

# 根据条件查询
expensive_products = session.query(Product).filter(Product.price > 100).all()
for product in expensive_products:
    print(product)

说明：

  • session.query(Model).all()：获取表中的所有记录。
  • filter：添加查询条件。

更新记录（Update）

修改已有记录并提交更改。

示例代码：

# 查询要更新的产品
product_to_update = session.query(Product).filter_by(name='无线鼠标').first()
if product_to_update:
    product_to_update.price = 44.99  # 更新价格
    product_to_update.stock += 50      # 增加库存
    session.commit()
    print(f"更新后的产品: {product_to_update}")
else:
    print("未找到指定的产品")

说明：

  • 通过查询获取要更新的对象，直接修改对象属性后提交事务。

删除记录（Delete）

删除指定记录并提交更改。

示例代码：

# 查询要删除的产品
product_to_delete = session.query(Product).filter_by(name='无线鼠标').first()
if product_to_delete:
    session.delete(product_to_delete)
    session.commit()
    print("产品已删除")
else:
    print("未找到指定的产品")

说明：

  • 使用session.delete删除对象，然后提交事务。

关系定义

在实际应用中，数据库表之间通常存在各种关系。SQLAlchemy支持定义和管理这些关系。

一对多关系

示例场景：一个Category（类别）有多个Product（产品）。

模型定义：

from sqlalchemy import ForeignKey
from sqlalchemy.orm import relationship

class Category(Base):
    __tablename__ = 'categories'

    id = Column(Integer, primary_key=True, autoincrement=True)
    name = Column(String(50), nullable=False, unique=True)
    products = relationship('Product', back_populates='category')

    def __repr__(self):
        return f"<Category(name='{self.name}')>"

class Product(Base):
    __tablename__ = 'products'

    id = Column(Integer, primary_key=True, autoincrement=True)
    name = Column(String(100), nullable=False)
    description = Column(Text)
    price = Column(Float, nullable=False)
    stock = Column(Integer, default=0)
    category_id = Column(Integer, ForeignKey('categories.id'))
    created_at = Column(TIMESTAMP, server_default=func.now())

    category = relationship('Category', back_populates='products')

    def __repr__(self):
        return f"<Product(name='{self.name}', price={self.price}, stock={self.stock})>"

说明：

  • ForeignKey：在Product模型中添加category_id列，作为外键引用categories.id。
  • relationship：在Category和Product模型中定义关系，back_populates用于双向关联。

使用示例：

# 创建新类别
new_category = Category(name='电子产品')
session.add(new_category)
session.commit()

# 创建新产品并关联类别
new_product = Product(name='智能手表', description='功能丰富的智能手表。', price=199.99, stock=80, category=new_category)
session.add(new_product)
session.commit()

# 查询类别及其产品
category = session.query(Category).filter_by(name='电子产品').first()
print(category)
for product in category.products:
    print(product)

多对多关系

示例场景：一个Student（学生）可以选修多个Course（课程），一个Course可以被多个Student选修。

模型定义：

from sqlalchemy import Table

# 关联表
student_course = Table('student_course', Base.metadata,
    Column('student_id', Integer, ForeignKey('students.id')),
    Column('course_id', Integer, ForeignKey('courses.id'))
)

class Student(Base):
    __tablename__ = 'students'

    id = Column(Integer, primary_key=True, autoincrement=True)
    name = Column(String(100), nullable=False)
    courses = relationship('Course', secondary=student_course, back_populates='students')

    def __repr__(self):
        return f"<Student(name='{self.name}')>"

class Course(Base):
    __tablename__ = 'courses'

    id = Column(Integer, primary_key=True, autoincrement=True)
    title = Column(String(100), nullable=False)
    students = relationship('Student', secondary=student_course, back_populates='courses')

    def __repr__(self):
        return f"<Course(title='{self.title}')>"

说明：

  • 使用Table定义关联表student_course，不需要单独的模型类。
  • 在Student和Course模型中通过relationship定义多对多关系，secondary参数指定关联表。

使用示例：

# 创建新学生和课程
student = Student(name='张三')
course1 = Course(title='Python编程')
course2 = Course(title='数据库管理')
session.add_all([student, course1, course2])
session.commit()

# 关联学生与课程
student.courses.append(course1)
student.courses.append(course2)
session.commit()

# 查询学生及其选修的课程
student = session.query(Student).filter_by(name='张三').first()
print(student)
for course in student.courses:
    print(course)

# 查询课程及其选修的学生
course = session.query(Course).filter_by(title='Python编程').first()
print(course)
for student in course.students:
    print(student)

一对一关系

示例场景：每个User（用户）有一个唯一的Profile（个人资料）。

模型定义：

class User(Base):
    __tablename__ = 'users'

    id = Column(Integer, primary_key=True, autoincrement=True)
    username = Column(String(50), nullable=False, unique=True)
    profile = relationship('Profile', uselist=False, back_populates='user')

    def __repr__(self):
        return f"<User(username='{self.username}')>"

class Profile(Base):
    __tablename__ = 'profiles'

    id = Column(Integer, primary_key=True, autoincrement=True)
    bio = Column(Text)
    user_id = Column(Integer, ForeignKey('users.id'))
    user = relationship('User', back_populates='profile')

    def __repr__(self):
        return f"<Profile(bio='{self.bio}')>"

说明：

  • 在User模型中，profile关系使用uselist=False表示一对一关系。
  • Profile模型通过user_id外键关联User模型。

使用示例：

# 创建新用户和个人资料
user = User(username='alice')
profile = Profile(bio='数据科学爱好者', user=user)
session.add(user)
session.add(profile)
session.commit()

# 查询用户及其个人资料
user = session.query(User).filter_by(username='alice').first()
print(user)
print(user.profile)

# 查询个人资料及其用户
profile = session.query(Profile).filter_by(bio='数据科学爱好者').first()
print(profile)
print(profile.user)

实践项目：使用SQLAlchemy构建博客系统

项目概述

本项目将通过构建一个简单的博客系统，展示如何使用SQLAlchemy进行数据库操作。博客系统包括User（用户）、Post（帖子）和Comment（评论）三个模型，展示一对多和多对一的关系。

步骤一：设置数据库

假设使用MySQL数据库，已创建名为blog的数据库，并安装了mysql-connector-python驱动。

数据库引擎创建：

from sqlalchemy import create_engine

DATABASE_URL = "mysql+mysqlconnector://root:your_password@localhost:3306/blog"
engine = create_engine(DATABASE_URL, echo=True)

步骤二：定义模型

模型定义：

from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, Text, ForeignKey, TIMESTAMP, func
from sqlalchemy.orm import relationship

Base = declarative_base()

class User(Base):
    __tablename__ = 'users'

    id = Column(Integer, primary_key=True, autoincrement=True)
    username = Column(String(50), nullable=False, unique=True)
    email = Column(String(100), nullable=False, unique=True)
    posts = relationship('Post', back_populates='author')
    comments = relationship('Comment', back_populates='author')

    def __repr__(self):
        return f"<User(username='{self.username}', email='{self.email}')>"

class Post(Base):
    __tablename__ = 'posts'

    id = Column(Integer, primary_key=True, autoincrement=True)
    title = Column(String(200), nullable=False)
    content = Column(Text, nullable=False)
    created_at = Column(TIMESTAMP, server_default=func.now())
    author_id = Column(Integer, ForeignKey('users.id'))
    author = relationship('User', back_populates='posts')
    comments = relationship('Comment', back_populates='post')

    def __repr__(self):
        return f"<Post(title='{self.title}', author='{self.author.username}')>"

class Comment(Base):
    __tablename__ = 'comments'

    id = Column(Integer, primary_key=True, autoincrement=True)
    content = Column(Text, nullable=False)
    created_at = Column(TIMESTAMP, server_default=func.now())
    author_id = Column(Integer, ForeignKey('users.id'))
    post_id = Column(Integer, ForeignKey('posts.id'))
    author = relationship('User', back_populates='comments')
    post = relationship('Post', back_populates='comments')

    def __repr__(self):
        return f"<Comment(author='{self.author.username}', post='{self.post.title}')>"

创建表：

# 创建所有表
Base.metadata.create_all(engine)

步骤三：执行CRUD操作

创建用户、帖子和评论：

from sqlalchemy.orm import sessionmaker

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

# 创建新用户
user1 = User(username='john_doe', email='john@example.com')
session.add(user1)
session.commit()

# 创建新帖子
post1 = Post(title='我的第一篇博客', content='这是我的第一篇博客内容。', author=user1)
session.add(post1)
session.commit()

# 创建评论
comment1 = Comment(content='很棒的文章！', author=user1, post=post1)
session.add(comment1)
session.commit()

print("用户、帖子和评论已创建")

读取帖子及其评论：

# 查询帖子
post = session.query(Post).filter_by(title='我的第一篇博客').first()
print(post)
for comment in post.comments:
    print(comment)

更新帖子内容：

# 更新帖子内容
post = session.query(Post).filter_by(title='我的第一篇博客').first()
if post:
    post.content = '这是更新后的博客内容。'
    session.commit()
    print("帖子内容已更新")

删除评论：

# 删除评论
comment = session.query(Comment).filter_by(content='很棒的文章！').first()
if comment:
    session.delete(comment)
    session.commit()
    print("评论已删除")

步骤四：定义模型关系

在上述模型定义中，已经展示了一对多和多对一的关系。以下进一步介绍如何使用back_populates和cascade参数管理关系。

示例代码：

# 删除用户时，级联删除其所有帖子和评论
class User(Base):
    __tablename__ = 'users'

    id = Column(Integer, primary_key=True, autoincrement=True)
    username = Column(String(50), nullable=False, unique=True)
    email = Column(String(100), nullable=False, unique=True)
    posts = relationship('Post', back_populates='author', cascade='all, delete-orphan')
    comments = relationship('Comment', back_populates='author', cascade='all, delete-orphan')

    # 其他部分保持不变

# 删除用户
user = session.query(User).filter_by(username='john_doe').first()
if user:
    session.delete(user)
    session.commit()
    print("用户及其相关帖子和评论已删除")

说明：

  • cascade='all, delete-orphan'：当删除User对象时，自动删除与之关联的Post和Comment对象，防止孤立数据。

常见问题及解决方法

问题1：如何处理数据库迁移？

原因：随着项目的发展，数据库的结构可能需要修改，如添加新表、修改列等。手动管理数据库迁移容易出错，需使用迁移工具。

解决方法：

  • Alembic：SQLAlchemy官方的数据库迁移工具，支持版本控制和自动生成迁移脚本。

安装Alembic：

pip install alembic

使用示例：

  1. 初始化Alembic：

    alembic init alembic

  2. 配置alembic.ini：设置数据库连接字符串。

  3. 编辑env.py：导入模型的元数据。

    from your_model_module import Base
target_metadata = Base.metadata

  4. 生成迁移脚本：

    alembic revision --autogenerate -m "Initial migration"

  5. 应用迁移：

    alembic upgrade head

说明：

  • 版本控制：Alembic跟踪数据库结构的变化，支持回滚和升级。
  • 自动生成：根据模型定义自动生成迁移脚本，减少手动操作。

问题2：如何优化查询性能？

原因：随着数据量的增加，未优化的查询可能导致性能下降。

解决方法：

  1. 使用索引：

    为常用的查询字段创建索引，加速数据检索。

    示例：

    from sqlalchemy import Index

class Product(Base):
    __tablename__ = 'products'
    # 列定义保持不变

Index('idx_product_price', Product.price)

  2. 懒加载与预加载：

    使用lazy参数控制关联对象的加载方式，避免不必要的数据库查询。

    示例：

    class Post(Base):
    __tablename__ = 'posts'
    # 列定义保持不变
    comments = relationship('Comment', back_populates='post', lazy='joined')

  3. 分页查询：

    对大量数据进行分页，减少一次性返回的数据量。

    示例：

    page = 2
per_page = 10
posts = session.query(Post).offset((page - 1) * per_page).limit(per_page).all()
for post in posts:
    print(post)

  4. 优化查询语句：

    避免不必要的JOIN和子查询，使用高效的过滤条件。

问题3：如何处理复杂关系？

原因：在复杂应用中，模型之间可能存在多种关系，如多对多、自关联等。

解决方法：

  1. 多对多关系：

    通过关联表管理多对多关系，如Student与Course。

  2. 自关联关系：

    模型与自身建立关系，如Employee与Manager。

    示例代码：

    class Employee(Base):
    __tablename__ = 'employees'

    id = Column(Integer, primary_key=True, autoincrement=True)
    name = Column(String(100), nullable=False)
    manager_id = Column(Integer, ForeignKey('employees.id'))
    subordinates = relationship('Employee', backref='manager', remote_side=[id])

    def __repr__(self):
        return f"<Employee(name='{self.name}', manager='{self.manager.name if self.manager else None}')>"

说明：

  • remote_side：指定关联的远端列，避免递归引用问题。
  • backref：为反向关系创建别名，方便访问。

总结

在本篇文章中，我们深入探讨了ORM（对象关系映射）的概念，介绍了SQLAlchemy的安装与配置，详细讲解了如何定义模型，执行CRUD操作，并展示了如何在模型之间定义各种关系。通过构建实际的博客系统项目，您不仅掌握了SQLAlchemy的基本用法，还了解了如何处理复杂的数据库关系和优化查询性能。

学习建议：

  1. 深入学习SQLAlchemy文档：了解更多高级功能，如事件系统、扩展库等，提升使用能力。
  2. 实践项目：通过构建实际项目，如电商平台、社交网络等，应用所学知识，积累实战经验。
  3. 学习数据库设计：掌握数据库规范化、索引优化和性能调优，提升数据库管理能力。
  4. 探索异步ORM：了解支持异步操作的ORM框架，如Tortoise ORM，适应现代异步Web框架的需求。
  5. 参与开源项目：通过贡献开源项目，学习业界最佳实践，扩展技术视野。

如果您有任何问题或需要进一步的帮助，请随时在评论区留言或联系相关技术社区。


http://www.kler.cn/a/519549.html

相关文章：

  • 粒子群算法 笔记 数学建模
  • 【测试】UI自动化测试
  • 【CSS入门学习】Flex布局设置div水平、垂直分布与居中
  • AIP-127 HTTP和gRPC转码
  • python：taichi 模拟一维波场
  • 手撕B-树
  • OpenEuler学习笔记（八）：安装OpenEuler
  • 14-6-3C++STL的list
  • 如何使用群晖NAS配置MySQL与phpMyAdmin远程管理
  • 商业航天更青睐哪些芯片
  • 网易Android开发面试题200道及参考答案 （下）
  • 长短期记忆网络LSTM
  • python爬虫入门（一） - requests库与re库，一个简单的爬虫程序
  • Kubernetes可视化界面
  • three.js+WebGL踩坑经验合集(3):THREE.Line的射线检测问题（不是阈值方面的，也不是难选中的问题）
  • IDEA2020同时使用SVN和GIT
  • DBO优化GRNN回归预测matlab
  • Altium Designer脚本开发不支持功能集锦
  • 接口（完）
  • 快速更改WampServer根目录php脚本
  • 如何写美赛（MCM/ICM）论文中的Summary部分
  • kafka-保姆级配置说明(consumer)
  • 【算法】递归型枚举与回溯剪枝初识
  • 基于Django的就业系统的设计与实现
  • 使用python gitlab包来实现更新gitlab wiki page
  • 25.日常算法