数据库是一个网站的基础。Flask可以使用很多种数据库。比如MySQL，MongoDB,SQLite,PostgreSQL等。这里我们以MySQL为例进行讲解。而在Flask中，如果想要操作数据库，我们可以使用ORM来操作数据库，使用ORM操作数据库将变得非常简单。

在讲解Flask中的数据库操作之前，先要安装这些模块

  • mysql：如果是在windows上,到官网下载。如果是ubuntu，通过命令sudo apt-get install mysql-server libmysqlclient-dev -yq进行下载安装。
  • pymysql：pymysql是用Python来操作mysql的包，因此通过pip来安装，命令如下：pip3 install pymysql
  • SQLAlchemy：SQLAlchemy是一个数据库的ORM框架，我们在后面会用到。安装命令为：pip3 install SQLAlchemy。

通过SQLAlchemy连接数据库

  1. constants.py存放数据库连接配置信息
from sqlalchemy import create_engine

# 数据库的配置变量 
HOSTNAME = '127.0.0.1'
PORT     = '3306'
DATABASE = 'demo0417'
USERNAME = 'root'
PASSWORD = 'root'
DB_URI = 'mysql+pymysql://{}:{}@{}:{}/{}'.format(USERNAME,PASSWORD,HOSTNAME,PORT,DATABASE)

首先从sqlalchemy中导入create_engine，用这个函数来创建引擎，然后用engine.connect()来连接数据库。其中一个比较重要的一点是，通过create_engine函数的时候，需要传递一个满足某种格式的字符串，对这个字符串的格式来进行解释

dialect+driver://username:password@host:port/database?charset=utf8

dialect是数据库的实现，比如MySQL、PostgreSQL、SQLite，小写。driver是Python对应的驱动，如果不指定，会选择默认的驱动，比如MySQL的默认驱动是MySQLdb。username是连接数据库的用户名，password是连接数据库的密码，host是连接数据库的域名，port是数据库监听的端口号，database是连接哪个数据库的名字。

  1. 通过constants.py的文件中的配置信息连接数据库，用SQLAlchemy执行原生SQL
from sqlalchemy import create_engine
from constants import DB_URI

#连接数据库
engine = create_engine(DB_URI,echo=True)

# 使用with语句连接数据库，如果发生异常会被捕获
with engine.connect() as con:
    # 先删除users表
    con.execute('drop table if exists authors')
    # 创建一个users表，有自增长的id和name
    con.execute('create table authors(id int primary key auto_increment,'name varchar(25))')
    # 插入两条数据到表中
    con.execute('insert into persons(name) values("abc")')
    con.execute('insert into persons(name) values("xiaotuo")')
    # 执行查询操作
    results = con.execute('select * from persons')
    # 从查找的结果中遍历
    for result in results:
        print(result)

ORM介绍

随着项目越来越大,采用原生SQL的方式在代码中会出现大量的SQL语句,对项目的进展非常不利

  • SQL语句重复利用率不高,越复杂的SQL语句条件越多,代码越长。会出现很多相近似的SQL语句
  • 很多SQL语句是在业务逻辑中拼出来的,如果有数据库需要更改,就要去修改这些逻辑,很容易漏掉某些SQL语句的修改
  • 写SQL时容易忽略web安全问题

ORM: Object Relationship Mapping,对象关系映射,通过ORM我们可以通过类的方式去操作数据库,而不用写原生的SQL语句。通过把表映射成类,把行作为实例,把字段作为属性,ORM在执行对象操作时候最终还是会把对应的操作转换为数据库原生语句

使用ORM的优点

  • 易用性：使用ORM做数据库的开发可以有效的减少SQL语句,写出来的模型也更加直观
  • 性能损耗小
  • 设计灵活：可以轻松写出来复杂的查询
  • 可移植性：SQLAlchemy封装了底层的数据库实现,支持多个关系型数据库,包括MySQL,SQLite

使用SQLAlchemy

要使用ORM来操作数据库，首先需要创建一个类来与对应的表进行映射。现在以User表来做为例子，它有自增长的id、name、fullname、password这些字段，那么对应的类为

from sqlalchemy import Column,Integer,String
from constants import DB_URI
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base

engine = create_engine(DB_URI,echo=True)
# 所有的类都要继承自declarative_base这个函数生成的基类
Base = declarative_base(engine)
class User(Base):
    # 定义表名为users
    __tablename__ = 'users'

    # 将id设置为主键，并且默认是自增长的
    id = Column(Integer,primary_key=True)
    # name字段，字符类型，最大的长度是50个字符
    name = Column(String(50))
    fullname = Column(String(50))
    password = Column(String(100))

    # 让打印出来的数据更好看，可选的
    def __repr__(self):
        return "<User(id='%s',name='%s',fullname='%s',password='%s')>" % (self.id,self.name,self.fullname,self.password)

SQLAlchemy会自动的设置第一个Integer的主键并且没有被标记为外键的字段添加自增长的属性。因此以上例子中id自动的变成自增长的。以上创建完和表映射的类后，还没有真正的映射到数据库当中，执行以下代码将类映射到数据库中

Base.metadata.create_all()

在创建完数据表，并且做完和数据库的映射后，接下来让我们添加数据进去

ed_user = User(name='ed',fullname='Ed Jones',password='edspassword')
# 打印名字
print(ed_user.name)
# 打印密码
print(ed_user.password)
# 打印id
print(ed_user.id)

可以看到，name和password都能正常的打印，唯独id为None，这是因为id是一个自增长的主键，还未插入到数据库中，id是不存在的。接下来让我们把创建的数据插入到数据库中。和数据库打交道的，是一个叫做Session的对象

from sqlalchemy.orm import sessionmaker
Session = sessionmaker(bind=engine)

# 或者
# Session = sessionmaker()
# Session.configure(bind=engine)

session = Session()
ed_user = User(name='ed',fullname='Ed Jones',password='edspassword')
session.add(ed_user)

现在只是把数据添加到session中，但是并没有真正的把数据存储到数据库中。如果需要把数据存储到数据库中，还要做一次commit操作

session.commit()
# 打印ed_user的id
print(ed_user.id)

这时候，ed_user就已经有id。 说明已经插入到数据库中了。有人肯定有疑问了，为什么添加到session中后还要做一次commit操作呢，这是因为，在SQLAlchemy的ORM实现中，在做commit操作之前，所有的操作都是在事务中进行的，因此如果你要将事务中的操作真正的映射到数据库中，还需要做commit操作。既然用到了事务，这里就并不能避免的提到一个回滚操作了，那么看以下代码展示了如何使用回滚

# 修改ed_user的用户名
ed_user.name = 'Edwardo'

# 创建一个新的用户
fake_user = User(name='fakeuser',fullname='Invalid',password='12345')
# 将新创建的fake_user添加到session中
session.add(fake_user)

# 判断`fake_user`是否在`session`中存在
print(fake_user in session)

# 从数据库中查找name=Edwardo的用户
tmp_user = session.query(User).filter_by(name='Edwardo')
# 打印tmp_user的name
print(tmp_user)

# 打印出查找到的tmp_user对象，注意这个对象的name属性已经在事务中被修改为Edwardo了。
> <User(name='Edwardo', fullname='Ed Jones', password='edspassword')>
# 刚刚所有的操作都是在事务中进行的，现在来做回滚操作
session.rollback()
# 再打印tmp_user
print(tmp_user)


# 再看fake_user是否还在session中
print(fake_user in session)

接下来看下如何进行查找操作，查找操作是通过session.query()方法实现的，这个方法会返回一个Query对象，Query对象相当于一个数组，装载了查找出来的数据，并且可以进行迭代。具体里面装的什么数据，就要看向session.query()方法传的什么参数了，如果只是传一个ORM的类名作为参数，那么提取出来的数据就是都是这个类的实例

for instance in session.query(User).order_by(User.id):
    print(instance)

如果传递了两个及其两个以上的对象，或者是传递的是ORM类的属性，那么查找出来的就是元组

for instance in session.query(User.name):
    print(instance)
for instance in session.query(User.name,User.fullname):
    print(instance)
for instance in session.query(User,User.name).all():
    print(instance)

另外，还可以对查找的结果（Query）做切片操作

for instance in session.query(User).order_by(User.id)[1:3]
    instance

如果想对结果进行过滤，可以使用filter_by和filter两个方法，这两个方法都是用来做过滤的，区别在于，filter_by是传入关键字参数，filter是传入条件判断，并且filter能够传入的条件更多更灵活

# 第一种：使用filter_by过滤：
for name in session.query(User.name).filter_by(fullname='Ed Jones'):
    print(name)

# 第二种：使用filter过滤：
for name in session.query(User.name).filter(User.fullname=='Ed Jones'):
    print(name)