flask-SQLAlchemy的一些笔记
所谓ORM技术是指将对数据库的操作映射到对类对象的操作，用起来更方便些。
python-flask中使用Flask-SQLAlchemy管理数据库，支持多种数据库后台。
安装方式为: sudo pip install flask-sqlalchemy
以下程序使用的数据库是mysql，除了一些配置参数稍有区别，其余对数据库类型没有影响
在flask程序中想要连接数据库需要在程序中加载一个配置参数:
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql+pymysql://usernamer:passwd@server/database'
db = SQLAlchemy(app)可以在代码中使用 db.create_all() 测试是否连接成功
1、数据库的使用
创建数据库使用 db.create_all() 实现， 删库使用 db.drop_all()。
如果数据库表已存在现有数据库中，那么 db.create_all() 不会执行任何更新操作或重建这个表，最粗暴的方法就是，删库再创建。
当然正确的做法应该是使用 Flask-Migrate 进行数据库迁移。
使用SQLAlchemy定义的数据模型需要继承自 db.Model 需要有一个类变量 __tablename__ 定义在数据库中使用的表名（如果省略了，会直接用类的类名作为表名）
其余类变量都是该模型的属性成员，被定义为 db.Column 的实例db.Column 类构造函数的第一个参数可省略，如果不省略则是一个字符串类型变量，表名在数据库中的列名，如果省略了则是是数据库列和模型属性的类型，其余参数指定属性的配置选项
示例：
class Article(db.Model):
__tablename__ = 'article'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(100), nullable=False)
content = db.Column(db.Text(), nullable=False)
def __repr__(self):
return '<Article %r>' % self.title常用的SQLAlchemy列类型
类型 | Python类型 | 说明 |
Integer | int | 普通整数,一般是32位 |
SmallInteger | int | 取值范围小的整数,一般是16位 |
BigInteger | int或long | 不限制精度的整数 |
Float | float | 浮点数 |
Numeric | decimal.Decimal | 定点数 |
String | str | 变长字符串,限长 |
Text | str | 变长字符串,不限长 |
Unicode | unicode | 变长unicode字符串,限长 |
UnicodeText | unicode | 变长unicode字符串,不限长 |
Boolean | bool | 布尔值 |
Date | datetime.date | 日期 |
Time | datetime.time | 时间 |
DateTime | datetime.datetime | 日期和时间 |
Interval | datetime.timedelta | 时间间隔 |
Enum | str | 一组字符串 |
PickleType | 任何Python对象 | 自动使用Pickle序列化 |
LargeBinary | str | 二进制文件 |
常用的SQLAlchemy列选项
选项名 | 说明 |
primary_key | 若为True,这列就是表的主键 |
unique | 若为True,这列不允许出现重复的值 |
index | 若为True,为这列创建索引,提升查询效率 |
nullable | 若为True,这列允许为null |
default | 为这列定义默认值 |
autoincrement | 若为true,则自增 |
Flask-SQLAlchemy要求每个模型都要定义主键，这一列常被命名为id。
虽然没有强制要求，但为一般会为模型定义一个 __repr__() 方法，返回一个具有可读性的字符串模型（和__str__()类似），可在调试和测试时使用。
2、数据库常用操作(增删改查)
1. 增
在数据库表中添加一行
在ORM技术中增加很简单，其实就是创建一个对象，然后进行事务提交即可。
具体操作如下：
art = Article(title='title1', content='text body')
db.session.add(art)
db.session.commit()如上所示， 构造一个模型对象，设置相应属性，最后进行事务提交即可。
2. 查
查找数据库中的一行数据
在ORM技术中，查找到的数据对象都被保存在模型对象中了。后面的改和删都是基于查找技术之上的。Flask-SQLAlchemy为每个模型类都提供了query对象，供查询使用
# 查找所有title为title1的数据库行
art = Article.query.filter(Article.title=='title1').all()
art = Article.query.filter_by(title='title1').all()
# 查找tittle为title1的第一行
art = Article.query.filter(Article.title=='title1').first()
art = Article.query.filter_by(title='title1')[0]首先看看前两行，这两行是查询所有title属性为title1的行，Article.query.filter(Article.title=='title1') 这一句其实相当于一个数据库查询语句，并没有直接获取所有数据库对象，想要看看原生的数据库查询语句可以打印下 str(Article.query.filter(Article.title=='title1'))
加个all()即可返回所有值的一个列表。若只需要第一个元素则可以直接first()
由前两行我们可以看出，按条件查询有两种常用方式，一种是 filter 另一种是 filter_by 。这两者的区别主要在于，filter是提供一种基本SQL查询，怎么说呢？看看filter方式的查询方法，至于一个 = 意味着赋值，也就是查询，按照谁等于谁的方法，当然filter可以提供多个参数，之间用,连接即可，也就是说想要用filter查询，你必须知道确切的取值。而filter_by则提供了一种更宽泛的查询，在其中可以进行一些逻辑比较之类的操作。
由后两句我们可以看出，前面的查询其实有点相当于一个列表了(只是相当于，我们还是需要用all()获取真正的所有对象的列表)，因此如果我们要取出第一个元素可以使用 first() 或者直接像 list 那样的操作。当然要取任意位置的元素还是只能用第二种了，但是这里还是比较推崇第一种，为什么呢？首先，一般需要取单个元素的一般都是第一个，因为要取一个出来的时候，一般都是唯一一个，而不是从一堆里乱取一个，如果有很多个满足条件，肯定是取列表。因此需求一般是取一个出来。那么为什么第一个比第二个好呢？因为如果没有满足条件的时候，第一种方式会返回一个 None 值，而第二个会抛出异常，判断 None 可比 try...except... 好处理些吧。
上面的 all, filter, filter_by 其实都是 query 上的的过滤器。
常用的SQLAlchemy查询过滤器
过滤器 | 说明 |
filter() | 把过滤器添加到原查询上,返回一个新查询 |
filter_by() | 把等值过滤器添加到原查询上,返回一个新查询 |
limit() | 使用指定的值限制原查询返回的结果数量,返回一个新查询 |
offset() | 偏移原查询返回的结果,返回一个新查询 |
order_by() | 根据指定条件对原查询进行排序,返回一个新查询 |
group_by() | 根据指定条件对原查询进行分组,返回一个新查询 |
看了上面说明那一栏应该能理解我上面说的，为什么前面的查询是相当于列表，而是不就是列表，因为它实际上还只是一个查询，还没有获取到具体的值对象。
在查询上应用指定过滤器后，还需要触发该查询获取真正的值对象。
除了上面介绍到了的 all(), first() 之外还有一些其它的方法。
常用的SQLAlchemy查询执行函数
方法 | 说明 |
all() | 以列表形式返回查询的所有结果 |
first() | 返回查询的第一个结果,如果没有结果,则返回None |
first_or_404() | 返回查询的第一个结果,如果没有结果,则终止请求,返回404错误响应 |
get() | 返回指定主键对应的行,如果没有对应的行,则返回None |
get_or_404() | 返回指定主键对应的行,如果没找到指定的主键,则终止请求,返回404错误响应 |
count() | 返回查询结果的数量 |
paginate() | 返回一个Paginate对象,它包含指定范围的结果 |
改
改其实就是把要修改的对象查找出来，进行属性值修改，再进行一次事务提交即可。
art = Article.query.filter_by(title='title1').first()
if art is not None:
art.title = 'new title'
db.session.commit()删
删除操作和修改操作是比较类似的，先查找出要删除的对象，进行删除操作，再进行一次事务提交即可。
art = Article.query.filter_by(title='title1').first()
if art is not None:
db.session.delete(art)
db.session.commit()顺带提下，事务回滚操作是 db.session.rollback()
数据库关系
首先定义两个表模型：
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(String(20), nullable=True)
def __repr__(self):
return "<user %s>" % self.username
class Article(db.Model):
__tablename__ = 'article'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(100), nullable=False)
content = db.Column(db.Text(), nullable=False)
author_id = db.Column(db.Integer)
def __repr__(self):
return "<article %s>" % self.title外键约束
关系型数据库有个非常重要的概念就是外键约束。
那么在 Flask-SQLAlchemy 中怎么指定外键约束呢?
class Article(db.Model):
author_id = db.Column(db.Integer, db.ForeignKey('user.id'))应该使用 ForeignKey 来设置，并且需要注意的是，括号里的参数 user.id 这里的 user 是表名(__tablename__)，而不是模型名(类名)。
反向引用
Flask-SQLAlchemy 中还提供了一种反向引用的关系。反向引用可以根据外键约束找到关联的关系模型，此时可以直接获取相关的模型对象，而不是外键的值。
class User(db.Model):
# ...
xxx = db.relationship('Article', backref='user')
class Article(db.Model):
# ...
yyy = db.relationship('User', backref='articles')这是干了个什么事儿呢？
假设有如下代码:
user = User(username="flask")
db.session.add(user)
db.session.commit()
art1 = Article(title="title1", content="text1", author_id=user.id)
art2 = Article(title="title2", content="text2", author_id=user.id)
db.session.add(art1)
db.session.add(art2)
db.session.commit()
# <user flask>
print(art1.user)
# <user flask>
print(art2.user)
# [<article title1>, <article title2>]
print(user.articles)可以看到，建立了外键关系的对象，可以直接通过反向关系直接访问有关键关系的模型对象。是不是非常方便？
下面看看这个是怎么用的：
可以很明显猜到是 xxx = db.relationship('Article', backref='user') 和 yyy = db.relationship('User', backref='articles') 这两句起的作用，分析下它们的共性，我们就能看明白反向引用的用法了。
首先 这里是随便定义了一个成员 xxx, yyy 这里想说的是，这里随便定义什么都不影响，这里只是举例告诉你不影响，所以随便取了名字，你以后在写的时候，最好不要这样，最好定义一些有意义的名字。
其次就是两个参数，第一个参数，不难发现，是和本表有外键约束的那个表的模型名(类名)而不是前面说的那样的是表名(__tablename__)。第二个参数，也还好理解，其实就是我们在进行反向引用时使用的那个变量。
我们在user表中加入了 articles 这个反向引用，我们就可以通过 u.articles 得到这个用户的所有article。同样，我们在article表中加入了 user 这个反向引用，我们就可以通过 art.user 得到这个art的user。
多对多关系
数据库中很多时候都需要我们定义一个多对多关系，数据库的正确处理方法是定义第三张表，SQLAlchemy中同样也是这样处理的。
首先定义两个数据模型，标签和文章。一个文章可能有多个标签，一个标签可能对应多个文章，所以就需要定义第三章表来处理这个关系了。
class Article(db.Model):
__tablename__ = 'article'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(100), nullable=False)
class Tag(db.Model):
__table__ = 'tag'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(20), nullable=False)下面我们需要定义第三张表了，格式如下：
# 表名 成员属性1 成员属性2
article_tag = db.Table('article_tag',
# 第一个参数是数据库属性名
db.Column('article_id', db.Integer, db.Foreign_key('article.id'), primary_key=True)
db.Column('tag_id', db.Integer, db.Foreign_key('tag.id'), primary_key=True)
)格式为创建一个 db.Table 的对象，注意这里不是再定义类了。然后传入第一个参数是数据库表名，然后两个参数就是相关联的两个表了。
这里db.Column多了一个字符串参数，这个参数其实就相当于前面写的 xxx = db.Column(...) 就相当于里面的xxx了，是属性名。
为什么这里要这样写呢？因为这里是在构造一个 db.Table 的对象，而不是在定义类成员属性了，所以就要换种方式写。
这里同样可以加入反向引用:
class Article(db.Model):
# ...
tags = db.relationship('Tag', secondary=article_tag, backref=db.backref('articles'))可以看到这里反向引用是借助了第二章表，并在secondary参数中指定了这个表。
