盘点Flask与数据库的交互插件FlaskSqlalchemy.docx
《盘点Flask与数据库的交互插件FlaskSqlalchemy.docx》由会员分享，可在线阅读，更多相关《盘点Flask与数据库的交互插件FlaskSqlalchemy.docx（17页珍藏版）》请在冰豆网上搜索。
盘点Flask与数据库的交互插件FlaskSqlalchemy
盘点Flask与数据库的交互插件--Flask-Sqlalchemy
前言
在我们做web开发的时候，经常需要用到与数据库交互，由于我们的数据通常都是保存在数据库中的，假如有人需要访问，就必需与数据库访问，所以今日我们引见一个Flask中与数据库交互的插件---Flask-Sqlalchemy。
一、安装并导入
pipinstallflask-sqlalchemy
fromflask_sqlalchemyimportSQLAlchemy
importos
importpymysqlasp
fromflaskimportFlask
二、基本用法
今日我们要了解的是Mysql数据库，所以这里重点引见连接Mysql数据库的方法。
1.连接数据库
1）.写在配置文件中然后读取
首先创建一个配置文件"config.py"，内容为：
db_type='mysql'
db_conn='pymysql'
host='127.0.0.1'
username='root'
password='123456'
port='3306'
db_name='people'
SQLALCHEMY_DATABASE_URI='{}+{}:
//{}:
{}@{}:
{}/{}?
charset=utf8'.format（db_type,db_conn,username,password,host,port,db_name）
SQLALCHEMY_COMMIT_ON_TEARDOWN=False
SQLALCHEMY_TRACK_MODIFICATIONS=True
然后在应用中导入配置文件：
fromflask_sqlalchemyimportSQLAlchemy
fromflaskimportFlask
importconfig
app=Flask（__name__）
app.config.from_object（config）#连接数据库配置文件
db=SQLAlchemy（app）
db.create_all（）#创建全部的数据库
2）.直接写在应用中读取
app=Flask（__name__）
p.install_as_MySQLdb（）#mysql连接器，由于不支持py3版本，所以必需加上这行
app.config['SECRET_KEY']=os.urandom（50）
app.config['SQLALCHEMY_DATABASE_URI']='mysql+pymysql:
//root:
123456@127.0.0.1:
3306/people'
app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN']=True#每次恳求结束后都会自动提交数据库中的变动
app.config['SQLALCHEMY_TRACK_MODIFICATIONS']=True#动态追踪修改设置，如未设置只会提示警告
db=SQLAlchemy（app）
还有很多其它的配置参数，比如：
SQLALCHEMY_NATIVE_UNICODE#可以用于显式禁用原生unicode支持
SQLALCHEMY_POOL_SIZE#数据库连接池的大小，默认是引擎默认值（5）
SQLALCHEMY_POOL_TIMEOUT#设定连接池的连接超时时间，默认是10
SQLALCHEMY_POOL_RECYCLE#多少秒后自动回收连接，mysql默认为2小时
SQLALCHEMY_RECORD_QUERIES#可以用于显式地禁用或启用查询记录
SQLALCHEMY_ECHO#为Ture时用于调试，显示错误信息
SQLALCHEMY_BINDS#一个映射binds到连接URI的字典
3）.使用独特的创建引擎
fromsqlalchemyimportcreate_engine
#echo参数为True时，会显示每条执行的SQL语句，为False时关闭
engine=create_engine（'mysql+pymysql:
//root:
123456@127.0.0.1:
3306/people',echo=True）
engine.connect（）
这样我们就算与People数据库建立连接了，接下来我们来建立一张表。
4）.创建连接多个数据库
app.config['SQLALCHEMY_BINDS']={
'users':
"mysql+pymysql:
//root:
123456@127.0.0.1:
3306/user",
'admin':
'sqlite:
//C:
/Users/Administrator/Desktop/admin',
'buy':
'postgresql:
//root:
123321@127.0.0.1/buy'
}
然后引用表：
db.create_all（bind=['users']）
db.create_all（bind='admin'）
指定Users数据库中的表：
__bind_key__='users'
bindkey内部存储在表的info字典中即：
info={'bind_key':
'users'}
2.建立数据表并插入值
1）.承继"db.Model"类
fromflask_sqlalchemyimportSQLAlchemy
fromflaskimportFlask
importconfig
app=Flask（__name__）
app.config.from_object（config）#添加配置文件
db=SQLAlchemy（app）
classUser（db.Model）:
__tablename__='users'
id=db.Column（db.Integer,primary_key=True,autoincrement=True）#整数类型的自增主键
username=db.Column（db.String（100）,nullable=False）#字符类型不为空
password=db.Column（db.String（100）,nullable=False）#字符类型不为空
def__init__（self,username,password）:
self.username=username
self.password=password
def__repr__（self）:
#打印当前类名和它的实例化后的值
return'%sis%r'%（self.__class__.__name__,self.username）
#恳求钩子,第一次恳求之前执行
@app.before_first_request
defcreate_table（）:
db.drop_all（）#删除全部表
db.create_all（）#创建新的表
@app.route（'/'）
defcreate（）:
use1=User（'hwhrr','123321'）
use2=User（'hwzjj','123456'）
use3=User（'hwzzz','654321'）
db.session.add_all（[use1,use2,use3]）#添加全部的用户,添加一个用户去掉_all后面加一个元祖即可
mit（）#提交数据
returnuse1.__repr__（）#前往用户1的值
if__name__=='__main__':
app.run（debug=True）
Column参数列表
name列名
type_类型
*args列表参数
Constraint（约束）,ForeignKey（外键）,ColumnDefault（默认）,Sequenceobjects（序列）定义
key列名的别名
primary_key假如为True，则是主键
nullable假如是True，则可以为null
default设置默认值，默认是None
index能否是索引，默认是True
unique能否独一键，默认是False
onupdate指定一个更新时候的值
autoincrement设置为整型自动增长
quote假如列明是关键字，则强制本义，默认False
2）.利用原始引擎来创建会话（略微简单点）
fromflaskimportFlask
fromsqlalchemyimportcreate_engine
fromsqlalchemy.ormimportsessionmaker
fromsqlalchemy.ext.declarativeimportdeclarative_base
fromsqlalchemyimportColumn,Integer,String
app=Flask（__name__）
Base=declarative_base（）
#创建连接数据库的引擎并且打开回显
engine=create_engine（"mysql+pymysql:
//root:
123456@localhost/people",echo=True）
Session=sessionmaker（bind=engine）#创建会话标记
classUser（Base）:
__tablename__='article'
id=Column（Integer,primary_key=True,autoincrement=True）
username=Column（String（100）,nullable=False）
password=Column（String（100）,nullable=False）
def__init__（self,username,password）:
self.username=username
self.password=password
def__repr__（self）:
return'%sis%r'%（self.__class__.__name__,self.username）
@app.before_first_request
defcreate_table（）:
Base.metadata.drop_all（engine）#删除全部数据库
Base.metadata.create_all（engine）#创建全部数据库
@app.route（'/'）
defindex（）:
user=User（"hwhrr","123321"）
session=Session（）#创建会话
session.add（user）#添加内容
mit（）#提交
returnuser.__repr__（）
if__name__=='__main__':
app.run（debug=True）
3.数据库之间的关系
1）.一对一
只需让两张表都在同等的位置上，属于双向关系。
classfather（db.Model）:
__tablename__='Father'
id=db.Column（db.Integer,primary_key=True,autoincrement=True）
name=db.Column（db.String（100）,nullable=False）
age=db.Column（db.Integer,nullable=False）
#次要是要在一个表上设置uselist然后设置back_populates的值为其它表的映射前往值
son_fa=db.relationship（'son',uselist=False,back_populates='fa_son'）
def__init__（self,name,age）:
self.name=name
self.age=age
def__repr__（self）:
return'%sis%r'%（self.__class__.__name__,self.name）
classson（db.Model）:
__tablename__='Son'
id=db.Column（db.Integer,primary_key=True,autoincrement=True）
name=db.Column（db.String（100）,nullable=False）
age=db.Column（db.Integer,nullable=False）
#这里无需设置uselist
fa_son=db.relationship（'father',back_populates='son_fa'）
def__init__（self,name,age）:
self.name=name
self.age=age
def__repr__（self）:
return'%sis%r'%（self.__class__.__name__,self.name）
2）.一对多
我们需要建立一个主表和一个子表，分别命名为“father”和‘son’，然后需要建立外键和反射来相互引用建立一种关系，我们来看看：
classfather（db.Model）:
__tablename__='Father'
id=db.Column（db.Integer,primary_key=True,autoincrement=True）
name=db.Column（db.String（100）,nullable=False）
age=db.Column（db.Integer,nullable=False）
#表示另一端是son这个模型，backref可替代Father.id访问father模型
son_fa=db.relationship（'son',backref='fa'，lazy='dynamic'）
#lazy表示加载方式：
#dynamic：
动态加载，只要用到了才加载只可以用在一对多和多对多关系中
#subquery：
全部加载
def__init__（self,name,age）:
self.name=name
self.age=age
def__repr__（self）:
return'%sis%r'%（self.__class__.__name__,self.name）
classson（db.Model）:
__tablename__='Son'
id=db.Column（db.Integer,primary_key=True,autoincrement=True）
name=db.Column（db.String（100）,nullable=False）
age=db.Column（db.Integer,nullable=False）
f_id=db.Column（db.Integer,db.ForeignKey（'Father.id'））#建立外键关联，指明表名和字段
def__init__（self,name,age）:
self.name=name
self.age=age
def__repr__（self）:
return'%sis%r'%（self._class__.__name__,self.name）
@app.route（'/'）
defcreate（）:
use1=father（'hw',45）
use2=son（'hyy',20）
db.session.add_all（[use1,use2]）
mit（）
returnuse1.__repr__（）+'\n'+use2.__repr__（）
3）.多对一
就是将反射应用在子表上，与父表同时进行关联。
classfather（db.Model）:
__tablename__='Father'
id=db.Column（db.Integer,primary_key=True,autoincrement=True）
name=db.Column（db.String（100）,nullable=False）
age=db.Column（db.Integer,nullable=False）
#表示另一端是son这个模型
son_fa=db.relationship（'son',back_populates="fath"）
def__init__（self,name,age）:
self.name=name
self.age=age
def__repr__（self）:
return'%sis%r'%（self.__class__.__name__,self.name）
classson（db.Model）:
__tablename__='Son'
id=db.Column（db.Integer,primary_key=True,autoincrement=True）
name=db.Column（db.String（100）,nullable=False）
age=db.Column（db.Integer,nullable=False）
f_id=db.Column（db.Integer,db.ForeignKey（'Father.id'））#建立外键关联
#表示另一端是father这个模型
fa_son=db.relationship（'father',back_populates="so"）
def__init__（self,name,age）:
self.name=name
self.age=age
def__repr__（self）:
return'%sis%r'%（self.__class__.__name__,self.name）
4）.多对多
设置一个关联表来对两个表同时进行管理。
#设置关联表
gl=db.Table（'glb',
db.Column（'id',db.Integer,primary_key=True,autoincrement=True）,
db.Column（'son_id',db.Integer,db.ForeignKey（'Son.id'））,
db.Column（'father_id',db.Integer,db.ForeignKey（'Father.id'））
）
#父表
classfather（db.Model）:
__tablename__='Father'
id=db.Column（db.Integer,primary_key=True,autoincrement=True）
name=db.Column（db.String（100）,nullable=False）
age=db.Column（db.Integer,nullable=False）
#设置关联表动态加载
son_fa=db.relationship（'son',secondary=gl,backref="fas",lazy="dynamic"）
def__init__（self,name,age）:
self.name=name
self.age=age
def__repr__（self）:
return'%sis%r'%（self.__class__.__name__,self.name）
#子表
classson（db.Model）:
__tablename__='Son'
id=db.Column（db.Integer,primary_key=True,autoincrement=True）
name=db.Column（db.String（100）,nullable=False）
age=db.Column（db.Integer,nullable=False）
def__init__（self,name,age）:
self.name=name
self.age=age
def__repr__（self）:
return'%sis%r'%（self.__class__.__name__,self.name）
可以看出我们已经创建出了一张关联表，名字就是我们设置的“glb”。
4.查看数据
1）.查看全部数据（all）
father.query.all（）
2）.精准查询（filter_by）
father.query.filter_by（name='hw'）.all（）#查找所出名字为hw的记录
3）.模糊查询（filter）
father.query.filter（father.name.startswith（'h'）.all（）#查找所出名字首字母为h的记录
4）.主键查询（get）
father.query.get
（1）#查看id为1的记录
5）.取反操作（not_）
fromsqlalchemyimportnot_
father.query.filter（not_（father.name=='hw'））.all（）#查找全部除了名字不是hw的记录
6）.与操作（and_）
fromsqlalchemyimportand_
#查找名字末尾是h并且年龄等于50的记录
father.query.filter（and_（father.name.endswith（'h'）,father.age==50））.all（）
7）.或操作（or_）
fromsqlalchemyimportor_
#查找名字末尾是h或者年龄等于50的记录
father.query.filter（or_（father.name.endswith（'h'）,father.age==50））.all（）
8）.一对多正向查询
son.query.filter_by（f_id=2）.all（）
9）.一对多反向查询
son.query.filter_by（fa=use1）.all（）
10）.查询第一个消灭的数据
son.query.filter（son.age==10）.first（）
son.query.filter（son.age==10）[0]
11）.查询对象并前往指定数量的结果
son.query.filter（son.age==10）.limit（10）.all（）#前往十个查找到的对象
12）.查询时指定偏移量
son.query.filter（son.age==10
升级会员 