Flask笔记：数据库ORM操做MySQL+pymysql/mysql-python+SQLAlchemy/Flask-SQLAlchemy

时间 2019-11-21

标签 flask 笔记数据库 orm mysql+pymysql mysql pymysql python+sqlalchemy python sqlalchemy 栏目 Python 繁體版

原文原文链接

　　Python中使用sqlalchemy插件能够实现ORM（Object Relationship Mapping，模型关系映射）框架，而Flask中的flask-sqlalchemy其实就是在sqlalchemy外进行了一层封装，使得在flask中使用起来更加方便，固然sqlalchemy的原有的方法也均可以使用。也就是说sqlalchemy在普通的Python程序中也可使用，而flask-sqlalchemy是为flask“定制”的。python

　　我这里使用的是MySQL数据库，Python3中对应的驱动插件为pymysql（Python2中对应的驱动插件为mysql-python），因此这里的数据库操做须要安装MySQL、pymysql（或mysql-python）和flask-sqlalchemy。mysql

1、MySQL数据库安装（其实MySQL的东西网上一大推）sql

　安装版：exe安装版按照步骤一步步来就好了，能够只安装MySQL服务便可，若是电脑上没有对应版本VS C++也会提示你安装的。数据库

　免安装版/解压版：根据如下步骤进行便可：flask

下载：将下载的zip包解压到任意目录。
配置环境变量：将解压后的文件夹中的bin目录路径放入环境变量的path中。
配置文件：在解压的文件夹下（也就是bin的上一级目录）新建一个ini配置文件如“my-default.ini”（若是有就须要修改其中的内容），在配置文件中写入（修改或追加）以下内容：

　　[mysqld]
　　basedir=D:\MySQL Server 8.0
　　datadir=D:\MySQL Server 8.0\datasession

　　注：解压后能够本身更改文件夹名称，好比我这儿是“MySQL Server 8.0”，配置这两个信息后，其中的“data”文件夹不要本身建立（默认是没有这个文件夹的，可是会在下一步自动建立），不然MySQL服务会启动失败。app

安装MySQL服务：在DOS窗口cd到bin目录，依次执行命令“mysqld -install”和“mysqld --initialize-insecure”（第二个命令会自动建立data文件夹，里面包含数据库的一些基本信息，而且该命令执行成功后是不会返回任何信息的）。
启动（中止）MySQL服务：执行命令“net start mysql”启动MySQL服务（中止服务是“net stop mysql”）。
设置密码：重开DOS窗口（保证是管理者权限），执行命令“mysqladmin -u root -p password”，回车，显示“Enter password”，不用输入任何东西直接回车（未设置密码时默认没有密码），显示“New password”，输入本身的密码便可，回车，显示“Confirm new password”，再次输入密码便可，回车，设置密码成功。
登陆：输入命令“mysql -u root -p”，回车，而后输入设置的密码便可。

　　安装和使用过程当中遇到的问题和解决方案：框架

使用命令“mysql -u root -p”输入密码后提示“access denied for user root @localhost(using password:YES)”，进不去数据库：删除所有文件夹从新安装“MySQL安装（解压版）”，从新设置一遍密码就OK了（关键是网上找了许多办法也无论用，只能这招了）。
运行Flask链接数据库时提示“Client does not support authentication protocol requested by server; consider upgrading MySQL client”：进入数据库后依次执行命名“USE mysql;”、“ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY '123456';”和“FLUSH PRIVILEGES;”，其中除了“'123456'”是我的设置的密码外，其余的字母和字符都copy就好了（第二条命令执行失败的话，从新进入数据库或者从新安装数据库再试一下吧，我第一次也没成功，后来重设密码后又成功了）。

2、数据库驱动插件安装（pymysql/mysql-python）ide

pymysql安装：Python3链接数据库的驱动插件为pymysql，直接用pip3 install pymysql便可。
mysql-python安装：Python2链接MySQL数据库的驱动为MySQL-python，也可以使用pip install MySQL-python，这里若是安装失败，可直接下载安装包进行安装：https://pypi.org/project/MySQL-python/#files。

3、SQLAlchemy使用函数

　　1.安装：pip install sqlalchemy

　　2.链接数据库：设置数据库链接字符串，并使用create_engine函数建立一个engine对象，并使用engine对象的connect方法链接数据库，注意链接数据库后须要使用close方法关闭链接。

from sqlalchemy import create_engine

# 数据库链接信息
HOSTNAME = '127.0.0.1'  # 本机地址
PORT = '3306'  # MySQL默认端口
DATABASE = 'sqlalchemy_demo'  # 数据库名
USERNAME = 'root'  # 安装数据库时设置的用户名和密码
PASSWORD = '123456'

# 数据库链接字符串
# dialect+driver://username:password@host:port/database
DB_URI = 'mysql+pymysql://{username}:{password}@{host}:{port}/{database}'.format(
    username=USERNAME, password=PASSWORD, host=HOSTNAME, port=PORT, database=DATABASE
)

# 建立一个engine对象
engine = create_engine(DB_URI)
# 链接数据库
conn = engine.connect()
# 执行SQL语句，并返回执行结果
sel_res = conn.execute('select * from User')
# 获取并打印一条查询结果
print(sel_res.fetchone())
# 关闭链接
conn.close()

　　3.定义模型类：使用declarative_base函数生成一个模型类的基类，以便模型类映射到数据库中，且必须使用__tablename__指定表名（一个类对应数据库中一张表，不一样的类实例对应表中不一样的记录）。

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

# 数据库链接信息
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'sqlalchemy_demo'
USERNAME = 'root'
PASSWORD = '123456'

# 数据库链接字符串
# dialect+driver://username:password@host:port/database
DB_URI = 'mysql+pymysql://{username}:{password}@{host}:{port}/{database}'.format(
    username=USERNAME, password=PASSWORD, host=HOSTNAME, port=PORT, database=DATABASE
)

# 建立一个engine对象
engine = create_engine(DB_URI)
# 建立全部模型类的基类
Base = declarative_base(engine)

# 注意如下定义全是在类中直接进行的，没有在__init__等方法中进行
class Person(Base):

    # 使用__table__name指定表名
    __tablename__ = 'person'

    # 定义属性字段id为整型、主键、自动增加
    id = Column(Integer, primary_key=True, autoincrement=True)
    # 定义属性字段name为最长50个字符的字符串类型，且非空
    name = Column(String(50), nullable=False)
    # 定义属性字段age为整型
    age = Column(Integer)

# 删除表，不用特意指定表，在加载Python文件时会自动检查定义了哪些表，并删除这些表
Base.metadata.drop_all()

# 将全部模型映射到数据库中，而且相同的模型类只在第一次执行时会生效，即若是第一次执行后，
# 又对类进行了修改，从新运行程序执行metadata.create_all()后并不会把更新的内容映射到数据库中，前提是数据库中的表没有被删除
Base.metadata.create_all()

　　4.经常使用数据类型：数据类型对应的类直接从模块sqlalchemy中导入便可。

- Integer: 整型。
- Float(32位)/Double(64位): 浮点类型，可能存在精度丢失的问题，这时候可使用DECIMAL定点类型。
- Boolean: True/False，对应数据库里的1/0。
- DECIMAL: 定点类型，须要指定数字的总位数（小数点前的位数+小数点后的位数）和小数位数。
- Enum: 枚举类型，须要指定全部的枚举值，且给这类型的字段赋值的时候就只能使用这几个指定的枚举值。
- Date: 日期类型（年月日），即datetime.date()。
- DateTime: 日期时间类型（年月日时分秒），即datetime.datetime()。
- Time: 时间类型（时分秒），即datetime.time()。
- String: 字符串类型，须要指定最大字符个数。
- Text: 文本类型。

　　5.Column经常使用参数：Column的第一个参数name用来指定数据中的属性名，若是不指定则默认为该属性变量名为属性名。

- name：数据库中的属性名，默认使用模型对应属性的变量名。
- type_：属性的数据类型（加下划线是由于Python已经有了关键字type）。
- default: 默认值，即没有给该属性赋值时采用默认值。
- nullable: 是否可为空，默认为True。
- primary_key: 是否为主键，默认False。
- unique: 是否惟一，默认为False。
- autoincrement: 是否自动增加，默认False。
- onupdate: 在某条记录更新的时候执行的函数（不管更新的内容是否是该属性字段都会执行）。

　　6.增删改查操做：使用sessionmaker建立session，并在session中进行增删改查操做，注意若是涉及到修改数据库，必定要commit后才能在数据库生效。

- 增长数据：可使用session的add(obj)方法（单条数据）和add_all([obj1, obj2, ...])（多条数据），最后使用commit方法提交修改。
- 删除数据：可使用session的delete(obj)删除数据，最后使用commit方法提交修改。
- 修改数据：直接对查询出的实例属性值进行从新赋值便可。
- 查询数据：可使用session的query方法获得query对象，再对query对象进行filter等过滤便可得出想要的查询结果，详细使用见示例代码。

增删改查简单示例（数据库链接代码和模型类代码见前面的代码示例）：

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

engine = create_engine(DB_URI)

# 别忘了实例化后再一次调用（加括号），会调用类的__call__生成session
session = sessionmaker(engine)()


# 增长数据
def add_data():
    p = Person(name='Jason', age=19)
    # 添加一条数据到内存中
    session.add(p)
    # 添加多条数据到内存中
    p1 = Person(name='Mickle', age=20)
    p2 = Person(name='Marya', age=21)
    session.add_all([p1, p2])
    # 提交到数据库中
    session.commit()


# 删除数据
def del_data():
    p = session.query(Person).first()
    # 直接删除提交便可
    session.delete(p)
    session.commit()


# 修改数据
def update_data():
    p = session.query(Person).first()
    # 获取对象后，直接修改提交便可
    p.name = 'JiuyunnZhao'
    session.commit()


# 查询数据
def search_data():
    # 查找模型类对应表的的全部数据（可用for遍历）
    # persons = session.query(Person).all()
    # 查询知足某个条件的全部数据（可for遍历），查询条件只有参数和一个等号（这种方式比较简单，由于只针对一个类）
    # persons = session.query(Person).filter_by(name='Mickle').all()
    # 查询知足某个条件的全部数据（可for遍历），查询条件类名.参数和双等号（filter中的条件能够更加复杂，这里只是简单举例）
    # persons = session.query(Person).filter(Person.name == 'Mickle').all()
    # for p in persons:
    #     print(p)
    # 根据主键查询某一条数据，没有对应的主键则返回None
    # p = session.query(Person).get(100)
    # 获取某张表的第一条数据
    p = session.query(Person).first()
    p = session.query(Person).filter(Person.name == 'Mickle').first()
    p = session.query(Person).filter_by(name='Mickle').first()
    print(p)


# 测试代码
if __name__ == '__main__':
    add_data()
    # del_data()
    # update_data()
    # search_data()

　　7.聚合函数：从sqlalchemy中导入func，func中有许多聚合函数可使用。其实func中没有“真正”的聚合函数，都是MySQL中的函数，也就是或MySQL中的聚合函数均可以在func中找到和使用。

- func.count(col_name)：统计某个字段的行数。
- func.avg(col_name)：统计某个字段的平均值。
- func.max: 统计某个字段的最大值。
- func.min: 统计某个字段的最小值。
- func.sum: 统计某个字段的和。
- 示例代码：session.query(func.avg(Person.age)).first()，结果是元组，其实也只有一条数据。

　　8.filter中的条件过滤（注意不是filter_by方法）：

- ==(equal)：如session.query(Person).filter(Person.name == 'Mickle').first()。
- !=(not equal)：如session.query(Person).filter(Person.name != 'Mickle').all()。
- like/ilike：后者不区分大小写，且两个方法查询条件中的通配符与SQL一致，如session.query(Person).filter(Person.name.like('Mi%')).all()。
- in_(in)：之因此有下划线，Python自己有in的关键字了，如session.query(Person).filter(Person.name.in_(['Mickle', 'Marya'])).all()。
- notin_(not in)：如session.query(Person).filter(Person.name.notin_(['Mickle', 'Marya'])).all()。
- ~(取反)：如session.query(Person).filter(~Person.name.in_(['Mickle', 'Marya'])).all()，这里的效果就至关于not in了。
- ==None/!=None(is null/is not null)：如session.query(Person).filter(Person.name == None).all()。
- and_(and)：这个方法不经常使用，使用方法：导入“from sqlalchemy import and_”，如session.query(Person).filter(and_(Person.name.like('M%'), Person.age == 18)).all()。经常使用的是session.query(Person).filter(Person.name.like('M%'), Person.age == 18).all()，多个and条件使用逗号分隔传参便可。
- or_(or)：导入“from sqlalchemy import or_”，如session.query(Person).filter(or_(Person.name.like('Mi%'), Person.name.like('Ma%'))).all()，多个or条件使用逗号分隔传参便可。

　　9.外键及外键约束：在想要定义为外键的列中传入参数ForeignKey('tablename.column_name')便可，若是想要定义外键约束，在ForeignKey中指定参数ondelete为相应约束便可，默认约束为RESTRICT。

- RESTRICT: 当要删除的父表中的数据在子表中有外键引用时，就会阻止删除操做，即不可删除。
- NO ACTION: 在MySQL中，效果同RESTRICT。
- CASCADE: 级联删除，即删除父表中的数据时，会同时删除与之有外键关联的子表的数据。
- SET NULL: 删除父表数据时，子表相应的外键列的值就会设置为NULL（此时，外键列的nullable属性就不可设置为False了，由于这自相矛盾，会报错的）。
- 注：在ORM中删除数据，即便用session.delete(xxx)时会无视MySQL数据库中的外键约束，能够直接删除数据库中的数据。当删除一条数据时，若是有从表引用了它，即从表中有它的外键时，按照MySQL中RESTRICT约束，会删除失败，可是直接在ORM的代码中使用session.delete(xxx)时，就会删除成功，且删除的步骤为，先将该数据对应的从表中的外键设置为NULL，再删除该条数据。因此为了不这种与数据库不一致的行为（略带危险性），须要给外键加上一个nullable=False的约束，这样不能设置为NULL后，就不会去进行后面的删除步骤了。

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

HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'sqlalchemy_demo'
USERNAME = 'root'
PASSWORD = '123456'

# dialect+driver://username:password@host:port/database
DB_URI = 'mysql+pymysql://{username}:{password}@{host}:{port}/{database}'.format(
    username=USERNAME, password=PASSWORD, host=HOSTNAME, port=PORT, database=DATABASE
)


engine = create_engine(DB_URI)
Base = declarative_base(engine)


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

# 子表
class Article(Base):
    __tablename__ = 'article'
    atc_id = Column(Integer, primary_key=True, autoincrement=True)
    title = Column(String(50), nullable=False)
    content = Column(Text, nullable=False)

    # 外键列，意为一个用户能够有多篇文章，注意此列的类型应该对应父表的主键类型一致
    # 注意这里是“表名.属性名”，而不是“类名.属性变量名”
    user_id = Column(Integer, ForeignKey('user.user_id', ondelete='CASCADE'))

　　10.外键关系：经过relationship将两个存在外键关联的两张表创建一个关系属性，并经过这个属性去进行互相访问。

- 一对一：在一张表中定义一个外键，另外一张表中定义一个到此表的关系，并指明relationship的参数uselist为False，表示此表与另外一张表是一对一的关系（默认是True，即一对多关系）；也可以使用backref函数进行反向引用，使得外键的定义和关系的定义均可以在同一个模型类中。
- 一对多：经过外键进行自动关联，且外键所在一方为“多”，另外一方为“一”；定义关系时可使用backref参数，使得外键的定义和关系的定义均可以在同一个模型类中；在“一”中定义的表示“多”的关系变量其实继承自list，因此append等方法也适用于它。
- 多对多：须要用到Table类生成中间表和relationship的参数secondary指明这个中间表。
- relationship参数：
  - 第一个参数：用于关联另外一张表时用的是类名，而不是表名。
  - backref：用于进行反向引用，便可以在backref中定义另外一张表对此表的引用。
  - secondary：用于多对多关系创建时指定中间表。
  - uselist：指定此表与另外一张表是一对一的关系。
  - cascade：指定关系的约束，能够指定多个约束，每一个值用逗号链接便可，且只会影响到定义cascade时所在的类，cascade参数值选项及含义以下：
    - save-update：默认选项，执行commit操做提交一条数据时，会将该数据经过relationship关联的其余数据一块儿更新到数据库中。
    - merge：也是默认选项，等效于session.merge(xxx)，当添加的数据和已有的数据冲突时，会替换掉已有的数据。
    - delete：当删除一条数据时，会同时删除与其经过relationship关联的其余数据。
    - delete-orphan：配合delete使用，只能使用在一对多的“一”中，表示当主表的数据被删除时，该数据的从表中的数据也会被删除。这种效果也能够在从表的relationship中指定参数single_parent=True来达到，这种状况下，就算是多对多的关系，只要删除了主表数据，从表的对应数据也会被删除，只是反过来就不行了，但delete-orphan是能够的，因此它使用的前提条件是一对多的“一”。
    - expunge：移除数据，等效于session.expunge(xxx)，与session.add(xxx)做用恰好相反。
    - all：等效于cascade='save-update,merge,refresh-expire,expunge,delete'(注意没有delete-orphan)。
  - lazy：值为dynamic时便可实现懒加载，即查询数据或append追加数据的时候并不会立刻进行数据库操做，而是返回一个AppenderQuery查询对象，在最后才进入数据库进行操做。

一对一关系简单示例：

# 一对一关系示例1：一张表定义外键，另外一张表定义一对一关系，即uselist=False
class User(Base):
    __tablename__ = 'user'
    user_id = Column(Integer, primary_key=True, autoincrement=True)
    username = Column(String(50), nullable=False)
    # 添加一个到模型Article的一对一关系，关键在于uselist=False，由于默认是True，那就是一对多了
    article = relationship('Article', uselist=False)


class Article(Base):
    __tablename__ = 'article'
    atc_id = Column(Integer, primary_key=True, autoincrement=True)
    title = Column(String(50), nullable=False)
    content = Column(Text, nullable=False)

    # 外键列“表名.属性名”，而不是“类名.属性变量名”
    user_id = Column(Integer, ForeignKey('user.user_id'))

    # 添加一个到模型User的关系，因为User类中定义了一对一uselist=False，因此这个关系天然也是一对一了，也不用再指定uselist=False
    author = relationship('User')


# 一对一示例2：利用反向引用函数backref创建一对一关系
# backref函数中的参数和relationship中的参数是一致的，relationship中可用的参数它均可以用
from sqlalchemy.orm import sessionmaker, relationship, backref


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


class Article(Base):
    __tablename__ = 'article'
    atc_id = Column(Integer, primary_key=True, autoincrement=True)
    title = Column(String(50), nullable=False)
    content = Column(Text, nullable=False)

    # 外键列
    user_id = Column(Integer, ForeignKey('user.user_id'))
    # 这里backref的使用至关于在User类中创建了一个名为article的关系，且参数uselist为False
    author = relationship('User', backref=backref('article', uselist=False))

一对多关系简单示例

# 一对多关系示例1
class User(Base):
    __tablename__ = 'user'
    user_id = Column(Integer, primary_key=True, autoincrement=True)
    username = Column(String(50), nullable=False)
    # 添加一个到模型Article的关系，一对多，表示“多”的的变量articles其实继承自list，因此append等方法也适用这个属性
    articles = relationship('Article')


class Article(Base):
    __tablename__ = 'article'
    atc_id = Column(Integer, primary_key=True, autoincrement=True)
    title = Column(String(50), nullable=False)
    content = Column(Text, nullable=False)

    # 外键列，注意这里是“表名.属性名”，而不是“类名.属性变量名”
    user_id = Column(Integer, ForeignKey('user.user_id'))

    # 添加一个到模型User的关系，多对一
    author = relationship('User')


# 一对多关系示例2
class User(Base):
    __tablename__ = 'user'
    user_id = Column(Integer, primary_key=True, autoincrement=True)
    username = Column(String(50), nullable=False)


class Article(Base):
    __tablename__ = 'article'
    atc_id = Column(Integer, primary_key=True, autoincrement=True)
    title = Column(String(50), nullable=False)
    content = Column(Text, nullable=False)

    # 外键列，注意这里是“表名.属性名”，而不是“类名.属性变量名”
    user_id = Column(Integer, ForeignKey('user.user_id'))

    # 反向引用，backref参数就至关于自动给User模型添加了一个名为articles且关联到User模型的的关系
    author = relationship('User', backref='articles')

# 使用示例，如下代码将在article表中添加两条数据
user =User(username='Mickle')
article1 = Article(title='aaa', content='1111')
article2 = Article(title='bbb', content='222')
user.articles.append(article1)
user.articles.append(article2)
session.add(user)
session.commit()

多对多关系简单示例

# 多对多关系示例：一篇文章能够有多个标签，一个标签也能够用于多篇文章
from sqlalchemy import create_engine, Column, Integer, String, Text, ForeignKey, Table
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker, relationship


HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'sqlalchemy_demo'
USERNAME = 'root'
PASSWORD = '123456'

# dialect+driver://username:password@host:port/database
DB_URI = 'mysql+pymysql://{username}:{password}@{host}:{port}/{database}'.format(
    username=USERNAME, password=PASSWORD, host=HOSTNAME, port=PORT, database=DATABASE
)

engine = create_engine(DB_URI)
Base = declarative_base(engine)
session = sessionmaker(engine)()


class Article(Base):
    __tablename__ = 'article'
    artcle_id = Column(Integer, primary_key=True, autoincrement=True)
    title = Column(String(50), nullable=False)

    # 与Tag创建关联关系和反向引用关系，并指明中间表为article_tag
    # 这个关系能够定义在关联的两张表中的任意一张表中均可以
    tags = relationship('Tag', backref='articles', secondary=article_tag)


class Tag(Base):
    __tablename__ = 'tag'
    tag_id = Column(Integer, primary_key=True, autoincrement=True)
    name = Column(String(50), nullable=False)


# 经过类Table来生成一个中间表
article_tag = Table(
    'article_tag',  # 表名
    Base.metadata,  # 继承的模型类型
    # 定义中间表中的列，声明此列关联到表article的列article_id，并指明以此列来做为复合主键的其中一列
    Column('article_id', Integer, ForeignKey('article.article_id'), primary_key=True),
    # 定义中间表中的列，声明此列关联到表tag的列tag_id，并指明以此列来做为复合主键的其中一列
    Column('tag_id', Integer, ForeignKey('tag.tag_id'), primary_key=True)
)

# 添加数据到数据库中
article1 = Article(title='my article 1')
article2 = Article(title='my article 2')
tag1 = Tag(name='my tag 1')
tag2 = Tag(name='my tag 2')
article1.tags.append(tag1)
article1.tags.append(tag2)
article2.tags.append(tag1)
article2.tags.append(tag2)
session.add(article1)
session.add(article2)
session.commit()

　　11.查询排序：默认升序，降序通常使用对应属性的desc()方法便可。

- session中指定排序：使用Query结果对象的order_by(attr_name)方法便可，降序使用order_by(attr_name.desc())或者使用“-”取反排序也可。
- __mapper_args__中指定排序：__mapper_args__是一个字典，设置键order_by的值为对应的属性便可，降序一样使用属性的desc()方法。
- realtionship中指定排序：设置order_by参数的值为对应的属性便可，降序一样使用属性的desc()方法。

升序降序简单示例：

# 如下列子以模型类Article中的字段create_time做为示例（字符串中的属性名是数据库中的属性名而不是变量名（没有定义时二者是同样的））
# 方式一：在session中使用order_by查询排序
# 升序
articles = session.query(Article).order_by(Article.create_time).all()
articles = session.query(Article).order_by('create_time').all()
# 降序）
articles = session.query(Article).order_by(Article.create_time.desc()).all()
articles = session.query(Article).order_by('-create_time').all()

# 方式2、在模型类中使用__mapper_args__的order_by指定查询排序
class Article(Base):
    __tablename__ = 'article'
    id = Column(Integer, primary_key=True, autoincrement=True)
    title = Column(String(50), nullable=False)
    create_time = Column(DateTime, nullable=False, default=datetime.now)

    __mapper_args__ = {
        'order_by': create_time,  # 升序
        # 'order_by': create_time.desc(),  # 降序
    }

# 方式3、使用模型类中relationship的roder_by进行指定查询排序
class User(Base):
    __tablename__ = 'user'
    id = Column(Integer, primary_key=True, autoincrement=True)
    username = Column(String(50), nullable=False)

class Article(Base):
    __tablename__ = 'article'
    id = Column(Integer, primary_key=True, autoincrement=True)
    title = Column(String(50), nullable=False)
    create_time = Column(DateTime, nullable=False, default=datetime.now)

    user_id = Column(Integer, ForeignKey('user.id'))

    author = realtionship('User', backref=backref('articles', order_by=create_time))  # 升序
    # author = realtionship('User', backref=backref('articles', order_by=create_time.desc()))  # 降序

　　12.query对象经常使用方法：

- limit：指定每次查询数据的条数，例只查找前面10篇数据：articles = session.query(Article).limit(10).all()。
- offset：指定查询的起始偏移量，例从第5条数据开始，并查询15条数据：articles = session.query(Article).offset(5).limit(15).all()。
- slice(start, stop)：指定查询的区间（切片操做），例查询第3到第18条数据：articles = session.query(Article)[3:18]或者articles = session.query(Article).slice(3, 18).all()，第一种方式最经常使用，第二种不太经常使用。

　　13.高级查询：

- group_by：实现查询分组，例根据年龄统计人数：session.query(User.age, func.count(User.id)).group_by(User.age).all()。
- having：对查询结果进行二次查询，例根据年龄统计人数并筛选出年龄小于18的分组：session.query(User.age, func.count(User.id)).group_by(User.age).having(User.age < 18).all()。
- join/outterjoin：即inner join和left join，例统计用户文章数看，并根据用户名分组，根据文章数排序：session.query(User.username, func.count(Article.id)).join(Article, User.id == Article.user_id).group_by(User.username).order_by(func.count(Article.id).desc()).all()，这里若是User和Article之间有惟一的外键在关联的话，join中的链接条件User.id == Article.user_id是能够不用写的，sqlalchemy会自动使用外键进行链接。
- subquery：对查询结果进行子查询，例如查找和用户“Jason”同年龄和同城市的用户：sub_q = session.query(User.city.label('city'), User.age.label('age')).filter(User.username == 'Jason').subquery(); q_res = session.query(User).filter(User.city == sub_q.c.city, User.age == sub_q.c.age).all()。

4、Flask-SQLAlchemy使用

　　因为Flask-SQLAlchemy实际上是SQLAlchemy在外面进行了一层封装，以便更好的适用于flask，因此Flask-SQLAlchemy和SQLAlchemy在使用上除了最外层封装的定义外都是同样的，下面只讲一些常须要注意的不一样之处

　　安装：pip install flask-sqlalchemy

　　1. 配置：须要在配置文件中配置数据库链接字符串“SQLALCHEMY_DATABASE_URI”，其中driver为Python2的mysqldb，Python3的pymysql，具体以安装的插件为准。

# 数据库链接固定格式格式字符串
# dialect+driver://username:password@host:port/database
DIALECT = 'mysql'
DRIVER = 'mysqldb'
USERNAME = 'root'
PASSWORD = 123456
HOST = '127.0.0.1'
PORT = '3306'
DATABASE = 'db_demo1'

SQLALCHEMY_DATABASE_URI = '{dialect}+{driver}://{username}:{password}@{host}:{port}/{database}?charset=utf8'.format(
    dialect=DIALECT, driver=DRIVER, username=USERNAME, password=PASSWORD, host=HOST, port=PORT, database=DATABASE
)

　　2.使用：Column、relationship等均可以直接在“from flask_sqlalchemy import SQLAlchemy”的SQLAlchemy实例中直接使用

- 实例化：实例化一个SQLAlchemy对象，须要使用一个Flask对象做为参数传入，若是实例化的时候不传入，能够在须要的时候使用init_app(flask_obj)方法传入。
- class模型：须要继承db.Model，对应数据库中的表，一个class实例对应一条记录。
- __tablename__：对应数据库中的表名，若未指定此变量的值，则使用class模型类名的全小写做为表名。

简单示例（配置信息写在了配置文件config.py中了）

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
import config

app = Flask(__name__)
app.config.from_object(config)
db = SQLAlchemy(app)
db.create_all()


class User(db.Model):
    __tablename__ = 'user'  # 设置表名，未设置则以类名全小写为表名
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)  # 定义列id，整型，主键，自增加
    username = db.Column(db.String(100), nullable=False)  # 定义列username，字符型（最大100个字符），非空