Flask框架——(数据库)

Flask框架——(数据库)

1. MySQL简介

介绍：
MySQL是⼀个关系型数据库管理系统，由瑞典MySQL AB公司开发，后来被Sun公司收购，Sun公司后来⼜被Oracle公司收购，⽬前属于Oracle旗下产品。

特点：

• 使用C和C++编写，并使用了多种编译器进行测试，保证源代码的可移植性。
• 支持多种操作系统，如Linux、Windows、AIX、FreeBSD、HP-UX、MacOS、NovellNetware、OpenBSD、OS/2 Wrap、Solaris等
• 为多种编程语言提供了API，如C、C++、Python、Java、Perl、PHP、Eiffel、Ruby等
• 支持多线程，充分利用CPU资源
• 优化的SQL查询算法，有效地提高查询速度
• 提供多语言支持，常见的编码如GB2312、BIG5、UTF8
• 提供TCP/IP、ODBC和JDBC等多种数据库连接途径
• 提供用于管理、检查、优化数据库操作的管理工具
• 大型的数据库。可以处理拥有上千万条记录的大型数据库
• 支持多种存储引擎
• MySQL 软件采用了双授权政策，它分为社区版和商业版，由于其体积小、速度快、总体拥有成本低，尤其是开放源码这一特点，一般中小型网站的开发都选择MySQL作为网站数据库
• MySQL使用标准的SQL数据语言形式
• Mysql是可以定制的，采用了GPL协议，你可以修改源码来开发自己的Mysql系统
• 在线DDL更改功能
• 复制全局事务标识
• 复制无崩溃从机
• 复制多线程从机

2. SQLAlchemy介绍和基本使用

2-1. SQLAlchemy介绍和安装

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

安装：

• 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。

2-2. 通过SQLAlchemy连接数据库

代码示例：

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)

# 创建数据库引擎
engine = create_engine(DB_URI)

#创建连接
with engine.connect() as con:
    result = con.execute('select * from students')
    print(result.fetchone())

代码讲解：

• create_engine：sqlalchemy中导⼊create_engine，⽤这个函数来创建引擎，需要满足特定的格式(dialect+driver://username:password@host:port/database?charset=utf8)
• engine.connect()：连接数据库

2-3. SQLAlchemy执⾏原⽣SQL

代码示例：

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)

#连接数据库
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)

3. SQLAlchemy-ORM介绍

3-1. ORM介绍

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

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

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

ORM的优点：

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

3-2. 使用SQLAlchemy

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

代码示例：1. 创建user表

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自动的变成自增长的。以上创建完和表映射的类后，还没有真正的映射到数据库当中，执行以下代码将类映射到数据库中

代码示例：2. 将user类映射到数据库

Base.metadata.create_all()

代码示例： 3. 添加数据

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的对象

代码示例：4. 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操作

代码示例：5. commit，存入数据库

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

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

代码示例： 5. 回滚

# 修改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的类名作为参数，那么提取出来的数据就是都是这个类的实例

代码示例：6. 查找query

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能够传入的条件更多更灵活

代码示例：7. 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)

4. SQLAlchemy常用数据类型

4-1. 常用数据类型

• Integer：整形。
• Float：浮点类型。
• Boolean：传递True/False进去。
• DECIMAL：定点类型。
• enum：枚举类型。
• Date：传递datetime.date()进去。
• DateTime：传递datetime.datetime()进去。
• Time：传递datetime.time()进去。
• String：字符类型，使用时需要指定长度，区别于Text类型。
• Text：文本类型。
• LONGTEXT：长文本类型。

4-2. Column常用参数

• default：默认值。
• nullable：是否可空。
• primary_key：是否为主键。
• unique：是否唯一。
• autoincrement：是否自动增长。
• onupdate：更新的时候执行的函数。
• name：该属性在数据库中的字段映射

4-3. query可用参数

1. 模型对象。指定查找这个模型中所有的对象。
2. 模型中的属性。可以指定只查找某个模型的其中几个属性。
3. 聚合函数。
   • func.count：统计行的数量。
   • func.avg：求平均值。
   • func.max：求最大值。
   • func.min：求最小值。
   • func.sum：求和。

4-4. 过滤条件

过滤是数据提取的一个很重要的功能，以下对一些常用的过滤条件进行解释，并且这些过滤条件都是只能通过filter方法实现的

equals

query.filter(User.name == 'ed')

not equals

query.filter(User.name != 'ed')

like

query.filter(User.name.like('%ed%'))

in

query.filter(User.name.in_(['ed','wendy','jack']))
# 同时，in也可以作用于一个Query
query.filter(User.name.in_(session.query(User.name).filter(User.name.like('%ed%'))))

not in

query.filter(~User.name.in_(['ed','wendy','jack']))

is null

query.filter(User.name==None)
# 或者是
query.filter(User.name.is_(None))

is not null

query.filter(User.name != None)
# 或者是
query.filter(User.name.isnot(None))

and

from sqlalchemy import and_
query.filter(and_(User.name=='ed',User.fullname=='Ed Jones'))
# 或者是传递多个参数
query.filter(User.name=='ed',User.fullname=='Ed Jones')
# 或者是通过多次filter操作
query.filter(User.name=='ed').filter(User.fullname=='Ed Jones')

or

from sqlalchemy import or_  query.filter(or_(User.name=='ed',User.name=='wendy'))

5. 外键及其四种约束

5-1. 外键

介绍：
在Mysql中，外键可以让表之间的关系更加紧密。⽽SQLAlchemy同样也⽀持外键。通过ForeignKey类来实现，并且可以指定表的外键约束。

代码示例：

class Article(Base):
    __tablename__ = 'article'
    id = Column(Integer,primary_key=True,autoincrement=True)
    title = Column(String(50),nullable=False)
    content = Column(Text,nullable=False)
    uid = Column(Integer,ForeignKey('user.id'))
    def __repr__(self):
        return "<Article(title:%s)>" % self.title


class User(Base):
    __tablename__ = 'user'
    id = Column(Integer,primary_key=True,autoincrement=True)
    username = Column(String(50),nullable=False)

常见的外键约束：

1. RESTRICT：⽗表数据被删除，会阻⽌删除。默认就是这⼀项。
2. NO ACTION：在MySQL中，同RESTRICT。
3. CASCADE：级联删除。
4. SET NULL：⽗表数据被删除，⼦表数据会设置为NULL。

5-2. 表关系

介绍：

表之间的关系存在三种：一对一、一对多、多对多。而SQLAlchemy中的ORM也可以模拟这三种关系。因为一对一其实在SQLAlchemy中底层是通过一对多的方式模拟的。

5-2-1. 一对多

介绍：
拿之前的User表为例，假如现在要添加一个功能，要保存用户的邮箱帐号，并且邮箱帐号可以有多个，这时候就必须创建一个新的表，用来存储用户的邮箱，然后通过user.id来作为外键进行引用

代码示例：

from sqlalchemy import ForeignKey
from sqlalchemy.orm import relationship
class Address(Base):
    __tablename__ = 'address'
    id = Column(Integer,primary_key=True)
    email_address = Column(String,nullable=False)
    user_id = Column(Integer,ForeignKey('users.id'))
    user = relationship('User',backref="addresses")
    def __repr__(self):
        return "<Address(email_address='%s')>" % self.email_address

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer,primary_key=True)
    name = Column(String(50))
    fullname = Column(String(50))
    password = Column(String(100))
    addresses = relationship("Address",backref="user")

5-2-2. 一对一

介绍：
一对一其实就是一对多的特殊情况，从以上的一对多例子中不难发现，一对应的是User表，而多对应的是Address，也就是说一个User对象有多个Address。因此要将一对多转换成一对一，只要设置一个User对象对应一个Address对象即可。

代码示例：

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer,primary_key=True)
    name = Column(String(50))
    fullname = Column(String(50))
    password = Column(String(100))

    addresses = relationship("Address",backref='addresses',uselist=False)
    
class Address(Base):
    __tablename__ = 'addresses'
    id = Column(Integer,primary_key=True)
    email_address = Column(String(50))
    user_id = Column(Integer,ForeignKey('users.id')
    user = relationship('Address',backref='user')

从以上例子可以看到，只要在User表中的addresses字段上添加uselist=False就可以达到一对一的效果

5-2-3. 多对多

介绍：

多对多需要一个中间表来作为连接，同理在sqlalchemy中的orm也需要一个中间表。假如现在有一个Teacher和一个Classes表，即老师和班级，一个老师可以教多个班级，一个班级有多个老师，是一种典型的多对多的关系，那么通过sqlalchemy的ORM的实现方式

代码示例：

association_table = Table(
    'teacher_classes',
    Base.metadata,
  	Column('teacher_id',Integer,ForeignKey('teacher.id')),
  	Column('classes_id',Integer,ForeignKey('classes.id'))
  )

class Teacher(Base):
    __tablename__ = 'teacher'
    id = Column(Integer,primary_key=True)
    tno = Column(String(10))
    name = Column(String(50))
    age = Column(Integer)
    classes = relationship('Classes',secondary=association_table,backref='teachers')

 class Classes(Base):
    __tablename__ = 'classes'
    id = Column(Integer,primary_key=True)
    cno = Column(String(10))
    name = Column(String(50))
    teachers = relationship('Teacher',secondary=association_table,backref='classes')

要创建一个多对多的关系表。
首先需要一个中间表，通过Table来创建一个中间表。上例中第一个参数teacher_classes代表的是中间表的表名，第二个参数是Base的元类，第三个和第四个参数就是要连接的两个表，其中Column第一个参数是表示的是连接表的外键名，第二个参数表示这个外键的类型，第三个参数表示要外键的表名和字段。

6. 排序和查询高级

6-1. 排序

1. order_by: 可以指定根据这个表中的某个字段进行排序，如果在前面加了一个-，代表的是降序排序。

2. 在模型定义的时候指定默认排序：有些时候，不想每次在查询的时候都指定排序的方式，可以在定义模型的时候就指定排序的方式。

   • 在模型定义中，添加以下代码

 __mapper_args__ = {
    
    
     "order_by": title
 }

3. 正向排序和反向排序：默认情况是从小到大，从前到后排序的，如果想要反向排序，可以调用排序的字段的desc方法。

6-2. limit、offset和切片

• limit：可以限制每次查询的时候只查询几条数据。
• offset：可以限制查找数据的时候过滤掉前面多少条。
• 切片：可以对Query对象使用切片操作，来获取想要的数据。

6-3. 查询高级

6-3-1. group_by

介绍： 根据某个字段进行分组。比如想要根据性别进行分组，来统计每个分组分别有多少人.

代码参考：
session.query(User.gender,func.count(User.id)).group_by(User.gender).all()

6-3-2. having

介绍： having是对查找结果进一步过滤。比如只想要看未成年人的数量，那么可以首先对年龄进行分组统计人数，然后再对分组进行having过滤。

代码参考：
result = session.query(User.age,func.count(User.id)).group_by(User.age).having(User.age >= 18).all()

6-3-3. join方法

介绍：
join查询分为两种，一种是inner join，另一种是outer join。默认的是inner join，如果指定left join或者是right join则为outer join。如果想要查询User及其对应的Address，则可以通过以下方式来实现。

代码示例：

for u,a in session.query(User,Address).filter(User.id==Address.user_id).all():
    print(u)
    print(a)

这是通过普通方式的实现，也可以通过join的方式实现，更加简单

for u,a in session.query(User,Address).join(Address).all():
    print(u)
    print(a)

当然，如果采用outerjoin，可以获取所有user，而不用在乎这个user是否有address对象，并且outerjoin默认为左外查询：

for instance in session.query(User,Address).outerjoin(Address).all():
	print(instance)

6-4. 别名

当多表查询的时候，有时候同一个表要用到多次，这时候用别名就可以方便的解决命名冲突的问题了:

代码示例：

from sqlalchemy.orm import aliased
adalias1 = aliased(Address)
adalias2 = aliased(Address)
for username,email1,email2 in session.query(User.name,adalias1.email_address,adalias2.email_address).join(adalias1).join(adalias2).all():
    print(username,email1,email2)

6-5. 子查询

介绍：

sqlalchemy也支持子查询，比如现在要查找一个用户的用户名以及该用户的邮箱地址数量。要满足这个需求，可以在子查询中找到所有用户的邮箱数（通过group by合并同一用户），然后再将结果放在父查询中进行使用：

代码示例：

from sqlalchemy.sql import func
# 构造子查询
stmt = session.query(Address.user_id.label('user_id'),func.count(*).label('address_count')).group_by(Address.user_id).subquery()
# 将子查询放到父查询中
for u,count in session.query(User,stmt.c.address_count).outerjoin(stmt,User.id==stmt.c.user_id).order_by(User.id):
    print u,count

从上面我们可以看到，一个查询如果想要变为子查询，则是通过subquery()方法实现，变成子查询后，通过子查询.c属性来访问查询出来的列。以上方式只能查询某个对象的具体字段，如果要查找整个实体，则需要通过aliased方法

代码示例：

stmt = session.query(Address)
adalias = aliased(Address,stmt)
for user,address in session.query(User,stmt).join(stmt,User.addresses):
print user,address

7. Flask-SQLAlchemy插件

介绍：

Flask-SQLAlchemy是对SQLAlchemy进行了一个简单的封装，使得我们在flask中使用sqlalchemy更加的简单。可以通过pip install flask-sqlalchemy。

1. 数据库初始化： 数据库初始化不再是通过create_engine

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from constants import DB_URI
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = DB_URI
db = SQLAlchemy(app)

2. ORM类： 之前都是通过Base = declarative_base()来初始化一个基类，然后再继承，在Flask-SQLAlchemy中更加简单了

class User(db.Model):
  id = db.Column(db.Integer,primary_key=True)
  username = db.Column(db.String(80),unique=True)
  email = db.Column(db.String(120),unique=True)
  
  def __repr__(self):
      return '<User %s>' % self.username

3. 映射模型到数据库表： 使用Flask-SQLAlchemy所有的类都是继承自db.Model，并且所有的Column和数据类型也都成为db的一个属性。但是有个好处是不用写表名了，Flask-SQLAlchemy会自动将类名小写化，然后映射成表名。
写完类模型后，要将模型映射到数据库的表中，使用以下代码创建所有的表

db.create_all()

4. 添加数据： 这时候就可以在数据库中看到已经生成了一个user表了。

admin = User('admin','[email protected]')
guest = User('guest','[email protected]')
db.session.add(admin)
db.session.add(guest)
db.session.commit()

• 添加数据和之前的没有区别，只是session成为了一个db的属性。
• 查询数据：查询数据不再是之前的session.query了，而是将query属性放在了db.Model上，所以查询就是通过Model.query的方式进行查询了

users = User.query.all()

• 删除数据：删除数据跟添加数据类似，只不过session是db的一个属性而已：

db.session.delete(admin)
db.session.commit()