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

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

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

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

　安装版：exe安装版按照步骤一步步来就行了，可以只安装MySQL服务即可，如果电脑上没有对应版本VS C++也会提示你安装的。

　免安装版/解压版：根据以下步骤进行即可：

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

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

　　注：解压后可以自己更改文件夹名称，比如我这儿是“MySQL Server 8.0”，配置这两个信息后，其中的“data”文件夹不要自己创建（默认是没有这个文件夹的，但是会在下一步自动创建），否则MySQL服务会启动失败。

安装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就行了（第二条命令执行失败的话，重新进入数据库或者重新安装数据库再试一下吧，我第一次也没成功，后来重设密码后又成功了）。

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

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

三、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__指定表名（一个类对应数据库中一张表，不同的类实例对应表中不同的记录）。

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

 创建所有模型类的基类
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等过滤即可得出想要的查询结果，详细使用见示例代码。

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

 declarative_base
from sqlalchemy.orm  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)
    p2 = Person(name=Marya)
    session.add_all([p1,p2])
     提交到数据库中
    session.commit()


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


 修改数据
 update_data():
    p = 获取对象后，直接修改提交即可
    p.name = JiuyunnZhao
    session.commit()


 查询数据
 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 == ).first()
    p = session.query(Person).filter_by(name=).first()
    (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后，就不会去进行后面的删除步骤了。

 sessionmaker

HOSTNAME = DATABASE
)


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


 父表
 User(Base):
    user
    user_id = Column(Integer,1)">True)
    username = Column(String(50),1)">False)

 子表
 Article(Base):
    article
    atc_id = Column(Integer,1)">True)
    title = Column(String(50),1)">False)
    content = Column(Text,1)">False)

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

　　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
 添加一个到模型Article的一对一关系，关键在于uselist=False，因为默认是True，那就是一对多了
    article = relationship(ArticleFalse)


 外键列“表名.属性名”，而不是“类名.属性变量名”
    user_id = Column(Integer,1)">))

     添加一个到模型User的关系，由于User类中定义了一对一uselist=False，所以这个关系自然也是一对一了，也不用再指定uselist=False
    author = relationship(User)


 一对一示例2：利用反向引用函数backref建立一对一关系 backref函数中的参数和relationship中的参数是一致的，relationship中可用的参数它都可以用
 sessionmaker,relationship,backref


 外键列
    user_id = Column(Integer,1)">))
     这里backref的使用相当于在User类中建立了一个名为article的关系，且参数uselist为False
    author = relationship(

一对多关系简单示例

 一对多关系示例1
 添加一个到模型Article的关系，一对多，表示“多”的的变量articles其实继承自list，所以append等方法也适用这个属性
    articles = relationship( 外键列，注意这里是“表名.属性名”，而不是“类名.属性变量名”
    user_id = Column(Integer,1)"> 添加一个到模型User的关系，多对一
    author = relationship( 一对多关系示例2
 反向引用，backref参数就相当于自动给User模型添加了一个名为articles且关联到User模型的的关系
    author = relationship(articles)

 使用示例，以下代码将在article表中添加两条数据
user =User(username=)
article1 = Article(title=aaa1111)
article2 = Article(title=bbb222)
user.articles.append(article1)
user.articles.append(article2)
session.add(user)
session.commit()

多对多关系简单示例

 多对多关系示例：一篇文章可以有多个标签，一个标签也可以用于多篇文章
= DATABASE
)

engine = declarative_base(engine)
session =
    artcle_id = Column(Integer,1)"> 与Tag建立关联关系和反向引用关系，并指明中间表为article_tag
     这个关系可以定义在关联的两张表中的任意一张表中都可以
    tags = relationship(Tagarticle_tag)


 Tag(Base):
    tag
    tag_id = Column(Integer,1)">True)
    name = Column(String(50),1)"> 通过类Table来生成一个中间表
article_tag = Table(
    article_tag 表名
    Base.metadata,1)"> 继承的模型类型
     定义中间表中的列，声明此列关联到表article的列article_id，并指明以此列来作为复合主键的其中一列
    Column(article_idarticle.article_id'),primary_key=True), 定义中间表中的列，声明此列关联到表tag的列tag_id，并指明以此列来作为复合主键的其中一列
    Column(tag_idtag.tag_idTrue)
)

 添加数据到数据库中
article1 = Article(title=my article 1my 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()

 方式二、在模型类中使用__mapper_args__的order_by指定查询排序

    id = Column(Integer,1)">False)
    create_time = Column(DateTime,nullable=False,default=datetime.now)

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

 方式三、使用模型类中relationship的roder_by进行指定查询排序
datetime.now)

    user_id = Column(Integer,1)">user.id))

    author = realtionship( 升序
     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()。

四、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
PASSWORD = 123456
HOST = db_demo1

SQLALCHEMY_DATABASE_URI = {dialect}+{driver}://{username}:{password}@{host}:{port}/{database}?charset=utf8.format(
    dialect=DIALECT,driver=DRIVER,username=USERNAME,host=HOST,1)">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  Flask
from flask_sqlalchemy  SQLAlchemy
 config

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


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

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

相关文章