Flask-sqlalchemy多表查询

- [基本查询- ```python# 头部信息from flask import Flaskfrom flask_sqlalchemy import SQLAlchemyapp = Flask(__name__)app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://root:mysql@192.168.35...

adsszl_no_one

1454人浏览 · 2019-12-13 21:55:28

adsszl_no_one · 2019-12-13 21:55:28 发布

- [基本查询

- ```python
# 头部信息
from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)

app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://root:mysql@192.168.35.231:3306/testdb'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['SQLALCHEMY_ECHO'] = True

db = SQLAlchemy(app)
```

- ```python
# 头部信息在最开始
class User(db.Model):
__tablename__ = 't_user' # 表名默认位类名小写
id = db.Column(db.Integer, primary_key=True) # 主键，默认自增
name = db.Column(db.String(20), unique=True) # 唯一约束

class Address(db.Model):
__tablename__ = 't_address'
id = db.Column(db.Integer, primary_key=True)
detail = db.Column(db.String(20))
user_id = db.Column(db.Integer) # 外键，记录用户的主键

@app.route("/")
def index():
db.drop_all() # 删除所有继承自db.Model的表
db.create_all() # 创建所有继承自db.Mdoel的表
# 增加数据
user1 = User(name='zs')
user2 = User(name='ls')
db.session.add_all([user1, user2])
db.session.flush() # 主动执行sql操作

adr1 = Address(detail='美国村一号', user_id=user1.id)
adr2 = Address(detail='德国2号', user_id=user1.id)
db.session.add_all([adr1, adr2])
db.session.commit()

# 查询关联数据
user_fir = User.query.filter_by(name='zs').first()
adr_fir = Address.query.filter_by(user_id=user_fir.id).all()
print(adr_fir)

return "index"


if __name__ == '__main__':
app.run()
```

- 关系属性

- ```python
# 头部信息在最开始
class User(db.Model):
__tablename__ = 't_user' # 表名默认位类名小写
id = db.Column(db.Integer, primary_key=True) # 主键，默认自增
name = db.Column(db.String(20), unique=True) # 唯一约束

# 定义关系属性 db.relationship('关联的类名')
addresses = db.relationship('Address')


class Address(db.Model):
__tablename__ = 't_address'
id = db.Column(db.Integer, primary_key=True)
detail = db.Column(db.String(20))
# 设置外键参数 db.ForeignKey('主表名.字段名')
user_id = db.Column(db.Integer, db.ForeignKey('t_user.id')) # 外键，记录用户的主键


@app.route("/")
def index():
db.drop_all() # 删除所有继承自db.Model的表
db.create_all() # 创建所有继承自db.Mdoel的表
# 增加数据
user1 = User(name='zs')
user2 = User(name='ls')
db.session.add_all([user1, user2])
db.session.flush() # 主动执行sql操作

adr1 = Address(detail='美国村一号', user_id=user1.id)
adr2 = Address(detail='德国2号', user_id=user1.id)
db.session.add_all([adr1, adr2])
db.session.commit()

"""使用关系属性来查询关联数据 1）定义外键参数 2）定义关系属性 ==本质：根据外键进行查询"""
# 查询关联数据
useraa = User.query.filter_by(name='zs').first()
print(useraa.addresses)

return "index"

if __name__ == '__main__':
app.run()

```

- ```sql
# 关系属性查询sql实现
SELECT t_address.id AS t_address_id, t_address.detail AS t_address_detail, t_address.user_id AS t_address_user_id FROM t_address WHERE %s = t_address.user_id (1,)
```

- 反向引用

- ```python
# 头部信息在最开始
# 1,设置反向关联属性查询#######################################################################
class User(db.Model):
__tablename__ = 't_user' # 表名默认位类名小写
id = db.Column(db.Integer, primary_key=True) # 主键，默认自增
name = db.Column(db.String(20), unique=True) # 唯一约束

# 定义关系属性 db.relationship('关联的类名')
addresses = db.relationship('Address')

class Address(db.Model):
__tablename__ = 't_address'
id = db.Column(db.Integer, primary_key=True)
detail = db.Column(db.String(20))
# 设置外键参数 db.ForeignKey('主表名.字段名')
user_id = db.Column(db.Integer, db.ForeignKey('t_user.id')) # 外键，记录用户的主键

# 定义反向关系属性
user_info = db.relationship('User')

# 查询关联数据
addr1 = Address.query.filter_by(id=1).first()
"""
SELECT t_address.id AS t_address_id, t_address.detail AS t_address_detail,t_address.user_id AS t_address_user_id FROM t_address WHERE t_address.id = %s LIMIT %s (1, 1)
"""
print(addr1.user_info)
"""
SELECT t_user.id AS t_user_id, t_user.name AS t_user_name FROM t_user WHERE t_user.id = %s (1,)
"""

```

- ```python
# 头部信息在最开始
class User(db.Model):
__tablename__ = 't_user' # 表名默认位类名小写
id = db.Column(db.Integer, primary_key=True) # 主键，默认自增
name = db.Column(db.String(20), unique=True) # 唯一约束

# 定义关系属性 db.relationship('关联的类名')
# addresses = db.relationship('Address')

# 设置backref参数,代替反向关系属性（和定义一个方向关系属性等效）
addresses = db.relationship('Address', backref='user_info')


class Address(db.Model):
__tablename__ = 't_address'
id = db.Column(db.Integer, primary_key=True)
detail = db.Column(db.String(20))
# 设置外键参数 db.ForeignKey('主表名.字段名')
user_id = db.Column(db.Integer, db.ForeignKey('t_user.id')) # 外键，记录用户的主键

# 定义反向关系属性
# user_info = db.relationship('User')


@app.route("/")
def index():
db.drop_all() # 删除所有继承自db.Model的表
db.create_all() # 创建所有继承自db.Mdoel的表
# 增加数据
user1 = User(name='zs')
user2 = User(name='ls')
db.session.add_all([user1, user2])
db.session.flush() # 主动执行sql操作

adr1 = Address(detail='美国村一号', user_id=user1.id)
adr2 = Address(detail='德国2号', user_id=user1.id)
db.session.add_all([adr1, adr2])
db.session.commit()

# 查询关联数据
addr1 = Address.query.filter_by(id=1).first()
print(addr1.user_info)

return "index"

if __name__ == '__main__':
app.run()
```

- ```sql
# 以上sql实现
SELECT t_address.id AS t_address_id, t_address.detail AS t_address_detail, t_address.user_id AS t_address_user_id FROM t_address WHERE t_address.id = %s LIMIT %s (1, 1)
SELECT t_user.id AS t_user_id, t_user.name AS t_user_name FROM t_user WHERE t_user.id = %s (1,)
```

- 动态查询

- ```python
# 头部信息在最开始
class User(db.Model):
__tablename__ = 't_user' # 表名默认位类名小写
id = db.Column(db.Integer, primary_key=True) # 主键，默认自增
name = db.Column(db.String(20), unique=True) # 唯一约束

# 设置参数lazy='dynamic'开启动态查询，关系属性不在返回数据对象，而是返回AppenderBaseQuery对象
# AppenderBaseQuery对象 1）和BaseQuery一样，可以接续复杂的查询条件 2）保留了列表的特性可以通过遍历/索引取值
addresses = db.relationship('Address', lazy='dynamic')


class Address(db.Model):
__tablename__ = 't_address'
id = db.Column(db.Integer, primary_key=True)
detail = db.Column(db.String(20))
# 设置外键参数 db.ForeignKey('主表名.字段名')
user_id = db.Column(db.Integer, db.ForeignKey('t_user.id')) # 外键，记录用户的主键

@app.route("/")
def index():
db.drop_all() # 删除所有继承自db.Model的表
db.create_all() # 创建所有继承自db.Mdoel的表
# 增加数据
user1 = User(name='zs')
user2 = User(name='ls')
db.session.add_all([user1, user2])
db.session.flush() # 主动执行sql操作

adr1 = Address(detail='美国村一号', user_id=user1.id)
adr2 = Address(detail='德国2号', user_id=user1.id)
db.session.add_all([adr1, adr2])
db.session.commit()

# 查询关联数据
useraa = User.query.filter_by(name='zs').first()

# 对关联数据进一步的条件过滤
adrs = useraa.addresses.filter(Address.detail.startswith('美国')).all()
print(adrs)

# 可以通过遍历/索引取值
adr = useraa.addresses[0]
print(adr)

return "index"

if __name__ == '__main__':
app.run()
```

- ```sql
# 以上sql实现
SELECT t_user.id AS t_user_id, t_user.name AS t_user_name FROM t_user WHERE t_user.name = %s LIMIT %s ('zs', 1)
SELECT t_address.id AS t_address_id, t_address.detail AS t_address_detail, t_address.user_id AS t_address_user_id FROM t_address WHERE %s = t_address.user_id AND (t_address.detail LIKE concat(%s, '%%')) (1, '美国')
SELECT t_address.id AS t_address_id, t_address.detail AS t_address_detail, t_address.user_id AS t_address_user_id FROM t_address WHERE %s = t_address.user_id LIMIT %s (1, 1)
```

- 关联/连接查询

- ```sql
# 使用连接查询
ret = db.session.query(User, Address).join(Address, User.id == Address.user_id).filter(User.name == 'zs')
print(ret)

SELECT t_user.id AS t_user_id, t_user.name AS t_user_name, t_address.id AS t_address_id, t_address.detail AS t_address_detail, t_address.user_id AS t_address_user_id FROM t_user INNER JOIN t_address ON t_user.id = t_address.user_id WHERE t_user.name = %s ('zs',)
```

- ```python
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from sqlalchemy.orm import Load

app = Flask(__name__)

app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://root:mysql@192.168.35.231:3306/testdb'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['SQLALCHEMY_ECHO'] = True

db = SQLAlchemy(app)

class User(db.Model):
__tablename__ = 't_user' # 表名默认位类名小写
id = db.Column(db.Integer, primary_key=True) # 主键，默认自增
name = db.Column(db.String(20), unique=True) # 唯一约束

addresses = db.relationship('Address')

class Address(db.Model):
__tablename__ = 't_address'
id = db.Column(db.Integer, primary_key=True)
detail = db.Column(db.String(20))
# 设置外键参数 db.ForeignKey('主表名.字段名')
user_id = db.Column(db.Integer, db.ForeignKey('t_user.id')) # 外键，记录用户的主键

@app.route("/")
def index():
db.drop_all() # 删除所有继承自db.Model的表
db.create_all() # 创建所有继承自db.Mdoel的表
# 增加数据
user1 = User(name='zs')
user2 = User(name='ls')
db.session.add_all([user1, user2])
db.session.flush() # 主动执行sql操作

adr1 = Address(detail='美国村一号', user_id=user1.id)
adr2 = Address(detail='德国2号', user_id=user1.id)
db.session.add_all([adr1, adr2])
db.session.commit()

# sqlalchemy中的关系属性设置为了懒查询机制，优点是：减少资源浪费，在需要关联数据时才会查询
# user_obj = User.query.filter_by(name='zs').first()
# print(user_obj.addresses)
# 关系属性和使用基本查询都是查询两次，先查用户数据，再查地址数据
# 如果查询目的就是查询关联的数据，那么两次查询的效率要低于一次查询，网络IO影响比较大

# 使用一次查询来查询关联数据 *********最快的是连接查询***********
# 子查询 select detail from t_address where user_id = (select id from t_user where name='zs');
# 全相乘笛卡尔积
# 笛卡尔积在SQL中的实现方式既是交叉连接(Cross Join)。所有连接方式都会先生成临时笛卡尔积表，笛卡尔积是关系代数里的一个概念，
# 表示两个表中的每一行数据任意组合,上图中两个表连接即为笛卡尔积(交叉连接)
# select t_address.detail from t_address, t_user where t_address.user_id = t_user.id and t_user.name='zs';
# 连接查询 select t_address.detail from t_address join t_user.id = t_address.user_id where t_user.name='zs';

# 使用连接查询
# ret = db.session.query(User, Address).join(Address, User.id == Address.user_id).filter(User.name == 'zs').all()
# print(ret)

# 进一步优化只查询指定的字段需求：只查询用户的id和地址的detail
ret = db.session.query(User, Address).options(Load(User).load_only(User.id), Load(Address).load_only(Address.detail)).join(Address, User.id ==Address.user_id).filter(User.name == 'zs').all()
print(ret)

return "index"

if __name__ == '__main__':
app.run()
```

- ```sql
# 以上sql实现
SELECT t_user.id AS t_user_id, t_address.id AS t_address_id, t_address.detail AS t_address_detail FROM t_user INNER JOIN t_address ON t_user.id = t_address.user_id
WHERE t_user.name = %s ('zs',)
```

CSDN学习社区

CSDN联合极客时间，共同打造面向开发者的精品内容学习社区，助力成长！

更多推荐

嵌入式作业（七）：基于Ardunio的STM32串口通信

嵌入式作业（七）0作业要求1Ardunio 完成STM32的串口通信（1）安装Ardunio IDE（2）stm32串口通信2关于 stduino IDE0作业要求安装 Ardunio IDE 和相关软件支持库，在Ardunio 完成STM32板子的串口通信程序：（1）持续向串口输出“Hello world！”；（2）当接收到“stop!”时，停止输出。网上有一个国人版的MCU集成开发平台， st

CSDN学习社区

JDBC详解

JDBC文章目录JDBC什么是JDBC?JDBC驱动程序:Java使用JDBC访问数据库的步骤:设置classpath:Oracle连接字符串的书写格式:简单的例子:常用数据库的驱动程序及JDBC URL:Oracle数据库:SQL Server数据库MySQL数据库Access数据库PreparedStatement接口:JNDI-数据源（Data Source）与连接池（Connection

CSDN学习社区

“模式识别与机器学习”学习笔记no2.再谈感知机

接**上篇：上篇主要进行了PLA，Pocket算法的理论过程分析和在给定数据集上利用pocket算法对数据集进行分类学习，得到错分数量最少的分类面。上篇中pocket算法的过程已经进行了编程和测试，框架已经建立了起来，这一篇主要上篇中没有提到或涉及不深的几个问题。1.数据集的构造。上篇是直接使用了题目给的向量，这次来根据正态分布来产生数据集。np.random.normal函数可以根据均值和方差生