SQLAlchemy 基础知识

 ̄綄美尐妖づ 提交于 2020-04-19 18:16:04

全栈工程师开发手册 (作者:栾鹏)
python教程全解

SQLAlchemy 基础

下面是一段官方 SQLAlchemy 使用示例,我们从这个例子出发,认识 SQLAlchemy。

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


# sqlite3/mysql/postgres engine
# 请先自己在 MySQL 中创建一个名为 test_tmp 的 database
engine = create_engine('mysql://root@localhost/test_tmp', echo=False)

Base = declarative_base()

Session = sessionmaker(bind=engine)

session1 = Session()
session2 = Session()

SessionNoAutoflush = sessionmaker(bind=engine, autoflush=False)
session3 = SessionNoAutoflush()


class User(Base):
    __tablename__  = 'user'

    id = Column(Integer, primary_key=True)
    name = Column(String(64))

autoflush 和 autocommit

session 是什么?

目前还不知道怎样直接给 session 下定义,但是我们可以通过它的一些用途来认识它, 在脑海里脑补出这个东西。

  1. session 会在需要的时候(比如用户读取数据、更新数据时)和数据库进行通信,获取数据对象,并有一个池子来维护这些对象,保证你访问数据时不出现意外的问题
  2. session 和连接(connection) 不等同,session 通过连接和数据库进行通信
  3. session 是 Query 的入口,当你想要发起查询的时候,一般用法是:session.Query(Model).filter_by(...).first()

如果不完全理解它,也没关系,有个大概印象即可,以后碰到具体的问题再具体分析, 到时候就可以针对性解决。

官方介绍 session 的资料:https://docs.sqlalchemy.org/en/13/orm/session_basics.html#what-does-the-session-do

autoflush 参数

首先,学习两个概念:flush 和 commit。

  • flush 的意思就是将当前 session 存在的变更发给数据库,换句话说,就是让数据库执行 SQL 语句。
  • commit 的意思是提交一个事务。一个事务里面可能有一条或者多条 SQL 语句
  • SQLAlchemy 在执行 commit 之前,肯定会执行 flush 操作;而在执行 flush 的时候,不一定执行 commit,这个主要视 autocommit 参数而定,后面会详细讲

当 autoflush 为 True 时(默认是 True),session 进行查询之前会自动把当前累计的修改发送到数据库(注意:autoflush 并不是说在 session.add 之后会自动 flush),举个例子(结合开始的代码):

# 创建了一个对象,这时,这个对象几乎没有任何意义,session 不知道它的存在
>>> user = User(name='cosven')
>>> 
# session1.add 这个对象之后,它被 session 放到它的对象池里面去了,但这时不会发送任何 SQL 语句给数据库,数据库目前仍然不知道它的存在
>>>  session1.add(user)
>>>  
# session1.Query 执行之前,由于 autoflush 是 True,session1 会先执行 session1.flush(),然后再发送查询语句
# 当 session 进行 flush 操作时,session 会先建立(选)一个和数据库的连接,然后将创建 user 的 SQL 语句发送给数据库
# 所以,这个查询是能查到 user 的
>>> session1.query(User).filter_by(name='cosven').first()
<__main__.User object at 0x1108f04e0>

如果 session 的 autoflush 为 False 的话,session 进行查询之前不会把当前累计的修改发送到数据库,而直接发送查询语句,所以下面这个查询是查不到对象的。

>>> session3.add(User(name='haha'))
>>> session3.query(User).filter_by(name='haha').first()  # None

再重复的总结一下:

session.flush 的意义:session 计算自己积累的变更,将变更对应的 SQL 语句发送给数据库。 autoflush 的意义:session 在进行查询之前,自动的进行一次 flush 操作。

autocommit 参数

commit 对应的概念是事务(transaction),默认情况下,session 参数 autocommit 的值是 False,SQLAlchemy 也推荐将它设置为 False。

注:MySQL client 默认是将 autocommit 设为 True 的,所以我们在 cli 中执行一条 SQL 语句,数据库的数据就会发生变化

这里复习一下一个基础知识点:在一个事务被提交之前,事务里面的修改只对当前事务可见,其它事务看不见。什么意思?我们看个例子

# ps: session1 的 autocommit 参数为 False, autoflush 参数为 True
# 当 session1 执行 add 操作时,
>>> session1.add(User(name='miao'))

# session1 中是可以查到这个 user 的
>>> session1.query(User).filter_by(name='miao').first()
<__main__.User object at 0x1108f00000>

# session3 中查不到
>>> session3.query(User).filter_by(name='miao').first()  # None

# 让 session1 提交一下当前的事务
>>> session1.commit()

# 再从 session3 中查
>>> session3.query(User).filter_by(name='miao').first() is not None
True

事务不仅可以提交,还可以 rollback,这里就不讲。

relationship & backref

falsk 官方文档 http://flask-sqlalchemy.pocoo.org/2.1/models/ 后发现,以前试图孤立地理解backref是问题之源,backref是与relationship配合使用的。

一对多关系

db.relationship()用于在两个表之间建立一对多关系。例如书中 roles 表中一个 User 角色,可以对应 users 表中多个实际的普通用户。实现这种关系时,要在“多”这一侧加入一个外键,指向“一”这一侧联接的记录。


class Role(db.Model):
# ...

users = db.relationship('User', backref='role')

class User(db.Model):

# ...

role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))

relationship & ForeighKey

大多数情况下, db.relationship() 都能自行找到关系中的外键, 但有时却无法决定把 哪一列作为外键。 例如, 如果 User 模型中有两个或以上的列定义为 Role 模型的外键, SQLAlchemy 就不知道该使用哪列。如果无法决定外键,你就要为 db.relationship() 提供额外参数,从而确定所用外键。(见书 P49)

relationship & backref

通过db.relationship(),Role 模型有了一个可以获得对应角色所有用户的属性users。默认是列表形式,lazy='dynamic'时返回的是一个 query 对象。即relationship提供了 Role 对 User 的访问。

backref正好相反,提供了 User 对 Role 的访问。

不妨设一个 Role 实例为 user_role,一个 User 实例为 u。relationship 使 user_role.users 可以访问所有符合角色的用户,而 backref 使 u.role 可以获得用户对应的角色。

示例


$ p manage.py shell


>>> user_role = Role.query.filter_by(name='User').all()


>>> user_role


[<Role u'User'>]

>>> user_role = Role.query.filter_by(name='User').first()

>>> user_role

<Role u'User'>

>>> user_role.users

<sqlalchemy.orm.dynamic.AppenderBaseQuery object at 0x1087c1050>

>>> user_role.users.order_by(User.username).all()

[<User u'alice78'>, <User u'andrea86'>, <User u'hmr'>]

>>> Role.query.all()

[<Role u'Moderator'>, <Role u'Administrator'>, <Role u'User'>]

>>> user_role.users.count()
3

>>> u = User.query.filter_by(username='hmr').first()

>>> u

<User u'hmr'>

>>> u.role

<Role u'User'>


一对一关系

除了一对多之外, 还有几种其他的关系类型。一对一关系可以用前面介绍的一对多关系表示, 但调用 db.relationship() 时要把 uselist 设为 False , 把“多”变成“一”。

多对多关系

如果你想要用多对多关系,你需要定义一个用于关系的辅助表。对于这个辅助表, 强烈建议 使用模型,而是采用一个实际的表:

tags = db.Table('tags',
    db.Column('tag_id', db.Integer, db.ForeignKey('tag.id')),
    db.Column('page_id', db.Integer, db.ForeignKey('page.id'))
)
class Page(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    tags = db.relationship('Tag', secondary=tags,
        backref=db.backref('pages', lazy='dynamic'))
classs Tag(db.Model):
    id = db.Column(db.Integer, primary_key=True)

这里我们配置 Page.tags 加载后作为标签的列表,因为我们并不期望每页出现 太多的标签。而每个 tag 的页面列表( Tag.pages )是一个动态的反向引用。 正如上面提到的,这意味着你会得到一个可以发起 select 的查询对象。

SQLAlchemy MySQL 调试小技巧

为 MySQL 打开查询 log

SET GLOBAL log_output = "FILE"; the default.
SET GLOBAL general_log_file = "/path/to/your/mysql.log";
SET GLOBAL general_log = 'ON';

然后在 shell 中 tail -f mysql.log,这样一来,当 MySQL 收到请求时,你就能看到一条日志, 这样可以方便你判断 session 执行什么操作时,会发送 SQL 语句,什么时候建立连接。

日志示例:

2018-11-08T15:12:41.332513Z    53 Query commit
2018-11-08T15:12:41.333753Z    53 Query rollback
2018-11-08T15:12:45.999996Z    43 Query select * from user

将上面的脚本导入 python 或者 ipython

python -i test.py

参考:https://blog.csdn.net/mr_hui_/article/details/83217566
https://zhuanlan.zhihu.com/p/48994990

易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!