python对象操作数据库—SQLAlchemy的基本介绍与简单使用

1.SQLAlchemy介绍

1.1.SQLAlchemy定义与解释

   数据库是一个网站的基础。 比如MySQL、MongoDB、SQLite、PostgreSQL等，这里我们以 MySQL为例进行讲解。 SQLAlchemy是一个ORM框架。SQLAlchemy是一个用于Python的SQL工具和对象关系映射（ORM）库。它允许你通过Python代码来与关系型数据库交互，而不必直接编写SQL语句。

   简单介绍一下**对象关系映射**吧，对象关系映射（英语：Object Relational Mapping，简称 ORM，或O/RM，或O/R mapping），是一种程序设计技术， 用于实现面向对象编程语言里不同类型系统的数据之间的转换。 从效果上说，它其实是创建了一个可在编程语言里使用的“虚拟对象数据库”。**大白话**：对象模型与数据库表的映射。

** 1.2.为什么要有SQLAlchemy？**

    随着项目的越来越大，采用写原生SQL的方式在代码中会出现大量重复的SQL语句，那么，**问题**就出现了：

    1.SQL语句重复利用率不高，越复杂的SQL语句条件越多，代码越长，会出现很多相近的SQL语句。

    2.很多SQL语句 是在业务逻辑中拼接出来的，如果数据库需要更改，就要去修改这些逻辑，这会容易漏掉对某些SQL语句的修改。

    3.写SQL时容易忽略web安全问题，造成隐患。

   而ORM可以通过类的方式去操作数据库而不用再写原生的SQL语 句，通过把表映射成类，把行作为实例(一条数据)，把字段作为属性，ORM在执行对象操作的时候最终还是会把对象的操作转换为数据库的原生语句，但使用ORM有许多优点：

    1.**易用性**：使用ORM做数据库开发可以有效减少重复SQL语句的概率，写出来的模型也更加直观、清晰。

    2.**性能损耗小**：ORM转换成底层数据库操作指令确实会有一些开销。但是从实际情况来看，这种性能损耗很少（不足5%），只要不是针对性能有严苛的要求，综合考虑开发效率、代码阅读性，带来的好处远大于性能损耗，而且项目越大作用越明显。

    3.**设计灵活**：可以轻松的写出复杂的查询。可移植性：SQLAlchemy封装了底层的数据库实现，支持多个关系数据库引擎，包括流行的 Mysql、PostgreSQL和SQLite，可以非常轻松的切换数据库。

2.SQLAlchemy的基本用法

** 2.1.安装SQLAlchemy**

   在使用SQLAlchemy之前，首先需要安装它。可以使用以下命令使用pip安装：

pip install sqlalchemy

** 2.2.连接数据库**

    使用SQLAlchemy连接到数据库，需要提供数据库的连接字符串，其中包含有关数据库类型、用户名、密码、主机和数据库名称的信息。

from sqlalchemy import create_engine

# 例如，连接到SQLite数据库
engine = create_engine('sqlite:///example.db')

** 2.3.定义数据模型**

    使用SQLAlchemy的ORM功能，可以定义Python类来映射数据库中的表。每个类对应数据库中的一张表，类的属性对应表中的列。

# 导入必要的模块
from sqlalchemy import Column, Integer, String, Sequence
from sqlalchemy.ext.declarative import declarative_base

# 创建一个基类，用于定义数据模型的基本结构
Base = declarative_base()

# 定义一个数据模型类，对应数据库中的 'users' 表
class User(Base):
    # 定义表名
    __tablename__ = 'users'

    # 定义列：id，是整数类型，主键（primary_key=True），并使用 Sequence 生成唯一标识
    id = Column(Integer, Sequence('user_id_seq'), primary_key=True)

    # 定义列：name，是字符串类型，最大长度为50
    name = Column(String(50))

    # 定义列：age，是整数类型
    age = Column(Integer)

** 2.4.创建表**

    通过在代码中调用

create_all

方法，可以根据定义的模型创建数据库表。

Base.metadata.create_all(engine)

2.5.插入数据

    使用SQLAlchemy进行插入数据的操作，首先需要创建一个会话（Session）对象，然后使用该对象添加数据并提交。

# 导入创建会话的模块
from sqlalchemy.orm import sessionmaker

# 使用 sessionmaker 创建一个会话类 Session，并绑定到数据库引擎（bind=engine）
Session = sessionmaker(bind=engine)

# 创建一个实例化的会话对象 session
session = Session()

# 创建一个新的 User 实例，即要插入到数据库中的新用户
new_user = User(name='John Doe', age=30)

# 将新用户添加到会话中，即将其添加到数据库操作队列中
session.add(new_user)

# 提交会话，将所有在此会话中的数据库操作提交到数据库
session.commit()

2.6.查询数据

    使用SQLAlchemy进行查询数据的操作，可以通过查询语句或使用ORM查询接口。

# 使用查询语句
result = engine.execute('SELECT * FROM users')

# 使用ORM查询接口
users = session.query(User).all()

3.SQLAlchemy实战—创建一个简单的博客系统

    假设我们要创建一个简单的博客系统，使用 SQLAlchemy 来实现数据库操作。在这个博客系统中，我们需要存储用户信息、文章信息以及评论信息。下面给出了一个简化的示例，相应的代码已简化。

3.1定义数据模型类

# 导入 SQLAlchemy 中所需的模块
from sqlalchemy import create_engine, Column, Integer, String, Text, ForeignKey
from sqlalchemy.orm import declarative_base, relationship

# 创建一个基类，用于定义数据模型的基本结构
Base = declarative_base()

# 定义数据模型类 User，对应数据库中的 'users' 表
class User(Base):
    __tablename__ = 'users'
    
    # 定义列：id，是整数类型，作为主键
    id = Column(Integer, primary_key=True)
    
    # 定义列：username，是字符串类型，最大长度为50，唯一且不可为空
    username = Column(String(50), unique=True, nullable=False)
    
    # 定义列：email，是字符串类型，最大长度为100，唯一且不可为空
    email = Column(String(100), unique=True, nullable=False)
    
    # 定义关系，与 Post 类的关系为一对多关系，通过 back_populates 指定反向关系属性名
    posts = relationship('Post', back_populates='author')

# 定义数据模型类 Post，对应数据库中的 'posts' 表
class Post(Base):
    __tablename__ = 'posts'
    
    # 定义列：id，是整数类型，作为主键
    id = Column(Integer, primary_key=True)
    
    # 定义列：title，是字符串类型，最大长度为100，不可为空
    title = Column(String(100), nullable=False)
    
    # 定义列：content，是文本类型，不可为空
    content = Column(Text, nullable=False)
    
    # 定义列：user_id，是整数类型，外键关联到 'users' 表的 id 列
    user_id = Column(Integer, ForeignKey('users.id'))
    
    # 定义关系，与 User 类的关系为多对一关系，通过 back_populates 指定反向关系属性名
    author = relationship('User', back_populates='posts')
    
    # 定义关系，与 Comment 类的关系为一对多关系，通过 back_populates 指定反向关系属性名
    comments = relationship('Comment', back_populates='post')

# 定义数据模型类 Comment，对应数据库中的 'comments' 表
class Comment(Base):
    __tablename__ = 'comments'
    
    # 定义列：id，是整数类型，作为主键
    id = Column(Integer, primary_key=True)
    
    # 定义列：text，是文本类型，不可为空
    text = Column(Text, nullable=False)
    
    # 定义列：user_id，是整数类型，外键关联到 'users' 表的 id 列
    user_id = Column(Integer, ForeignKey('users.id'))
    
    # 定义列：post_id，是整数类型，外键关联到 'posts' 表的 id 列
    post_id = Column(Integer, ForeignKey('posts.id'))
    
    # 定义关系，与 User 类的关系为多对一关系
    author = relationship('User')
    
    # 定义关系，与 Post 类的关系为多对一关系，通过 back_populates 指定反向关系属性名
    post = relationship('Post', back_populates='comments')

    在上述代码中，我们定义了三个数据模型类：

User

（用户）、

Post

（文章）和

Comment

（评论）。这些类之间通过外键和关系进行关联。

3.2.创建数据库引擎和会话

# 导入 SQLAlchemy 中所需的模块
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

# 创建一个 SQLite 数据库引擎，连接到名为 'blog.db' 的数据库文件
engine = create_engine('sqlite:///blog.db')

# 使用 Base 对象的 metadata 属性，创建数据库中定义的所有表
Base.metadata.create_all(engine)

# 使用 sessionmaker 创建一个会话类 Session，并将其绑定到上面创建的数据库引擎
Session = sessionmaker(bind=engine)

# 创建一个实例化的会话对象 session，用于进行数据库操作
session = Session()

    这里我们选择了 SQLite 数据库，并使用 

create_all

创建相应的表。

3.3.进行数据库操作

# 创建一个新用户对象并设置其属性
user1 = User(username='john_doe', email='[email protected]')

# 将新用户对象添加到会话，表示要进行数据库插入操作
session.add(user1)

# 提交会话，将所有在此会话中的数据库操作提交到数据库
session.commit()

# 创建一篇新文章对象并设置其属性
post1 = Post(title='Introduction to SQLAlchemy', content='SQLAlchemy is a powerful ORM for Python.')

# 将文章的作者关联到之前创建的用户
post1.author = user1

# 将新文章对象添加到会话，表示要进行数据库插入操作
session.add(post1)

# 提交会话，将所有在此会话中的数据库操作提交到数据库
session.commit()

# 创建一条新评论对象并设置其属性
comment1 = Comment(text='Great article!', author=user1, post=post1)

# 将评论对象添加到会话，表示要进行数据库插入操作
session.add(comment1)

# 提交会话，将所有在此会话中的数据库操作提交到数据库
session.commit()

# 查询用户名为 'john_doe' 的用户，并打印其所有文章及评论
user = session.query(User).filter_by(username='john_doe').first()
print(f"User: {user.username}")

# 遍历用户的所有文章
for post in user.posts:
    print(f"Post: {post.title}")

    # 遍历文章的所有评论
    for comment in post.comments:
        print(f"Comment: {comment.text}")

    这段代码演示了如何使用 SQLAlchemy 对数据库进行插入和查询操作。首先，创建了一个用户、一篇文章和一条评论，然后通过查询用户的方式，打印出该用户的所有文章及评论。 

4.总结

    SQLAlchemy 提供了灵活的查询接口、事务管理、连接池等功能，使得 Python 开发者能够以更高层次的抽象进行数据库操作，提高了代码的可读性和可维护性。