SQLAlchemy与sql语句

先创建sqlalchemy对象 db

增加

单一新增：

# SQLAlchemy:
db.session.add(user)
db.session.commit()
# sql:
inster into 表名 values()

批量新增：

# SQLAlchemy:
db.session.add_all([user1,user2...]),
db.session.commit()
#sql:
inster into 表名 values()

查询

all():查询所有，返回列表

User.query.all()
sql:
select .. from tb1

fitst():查询第一个，返回对象

User.query.first()
sql:
select .. from tb1 limit 1

get():根据主键id获取对象，主键不存在返回None

User.query.get(2)
sql:
select .. from tb1 where id=2

filter_by:过滤查询

User.query.filter_by(mobile='15910743133').first()
User.query.filter_by(moblie='15910743133',id=1).first()
sql:
select .. from tb1 where mobile='15910743133' limit 1
select .. from tb1 where mobile='15910743133' and id=1 limit 1

filter:过滤查询

User.query.filter(User.mobile=='15910743133').first()
sql:
select .. from tb1 where mobile='15910743133' limit 1

or:

from sqlalchemy import or_
User.query.filter(or_(User.mobile=='15910743133',User.name=='itcast')).all()
sql:
select .. from tb1 where mobile='15910743133' or name='itcast'

and:

from sqlalchemy import and_
User.query.filter(and_(User.name != '13911111111',name='itcast' )).all()
sql:
select ..from tb1 where mobile='15910743133' or name='itcast'

or:

from sqlalchemy import not_
User.query.filter(not_(User.mobile == '15910743133')).all()
sql:
select..from tb1 where mobile!='15910743133'

limit:获取限制数据

User.query.limit(3).all()
sql:
select .. from tb1 limit 3

User.query.offset(2).limit(3).all()
sql:
select .. from tb1 limit 2,3

order_by:排序

User.query.order_by(User.id).all()  # 正序
User.query.order_by(User.id.desc()).all()  # 倒序
sql：
select .. from tb1 order by user_id
select .. from tb1 order by user_id desc

组合查询：　

User.query.filter(User.id > 1).order_by(User.id.desc()).offset(5).limit(3).all()
sql:
select ... from .. where user_id > 1 order by user_id desc limit 5,3

优化查询:

from sqlalchemy.orm import load_only
User.query.options(load_only(字段1，字段2...)).filter_by(id=1).first()
sql:
select 字段1，字段2，from tb1 where id=1 limit 1

分组聚合查询：

from sqlalchemy import func
db.session.query(Relation.user_id,func.count(Relation.target_user_id)).group_by(Relation.user_id).all()
#列表中的每个元祖都是数据库结果的一条记录，元祖中的每个元素 都是对应的结果字段
sql:
select user_id,count(target_user_id) from user_relation group by user_id;

关联查询：

* 通过对象属性获取相关联的表数据，惰性查询

* ForeignKey() + relationship

* relationship + primaryjoin

* 第一种方式：

* 通过db.ForeignKey('数据库表名.数据库字段名') 来表名两个表(模型类)之间的关系

* 通过向模型类补充relationship() 类型的字段属性来明确，当读取这个属性时要进行关联查询

* relationship 类型的属性默认返回列表，列表中是关联的模型类对象

* `uselist ` 如果明确知道表之间是一对一的关系，relationship 属性返回的肯定只有一个模型类对象，所以此时如果不想以列表返回，可以使用uselist=False,直接返回关联的模型类对象

* `lazy` 用于控制如何加载关联对象( 是多次查询还是一次join查询)

* `select` 默认在读取关联属性的时候进行二次查询查询关联表
* `joined` 在查询主对象的时候直接使用join语句完成主表与关联表的数据一起查询
* `dynamic` 动态每次获取关系属性时都要查询数据库 (注意使用dynamic时不能使用uselist=False)

* `backref` 反引用

```python
class User():

profile = db.relationship('UserProfile', uselist=False, backref='user')
```

backref 是指为UserProfile 模型类补充一个用于进行关联查询的属性 user，当在UserProfile对象中读取user属性的时候，会返回关联的User对象

* 第二种方式：
* 不再通过db.ForeignKey来明确表的关系，而是通过relationship 关系属性中使用primaryjoin 参数来明确表的关系
* 通过向模型类补充relationship() 类型的字段属性来明确，当读取这个属性时要进行关联查询

     
#查询手机号为13912345678用户所关注的所有用户
sql：      
select user_basic.user_id, user_relation.target_user_id from user_relation join user_basic on user_relation.user_id=user_basic.user_id where user_basic.mobile='13912345678'
        
from sqlalchemy.orm import load_only, contains_eager
User.query.join(User.follows).options(load_only(User.id),  contains_eager(User.follows).load_only(Relation.target_user_id))

猜你喜欢