ORM层面的CASCADE:

如果将数据库的外键设置为RESTRICT,那么在ORM层面,删除了父表中的数据,那么从表中的数据将会NULL。如果不想要这种情况发生,那么应该将这个值的nullable=False

SQLAlchemy,只要将一个数据添加到session中,和他相关联的数据都可以一起存入到数据库中了。这些是怎么设置的呢?其实是通过relationship的时候,有一个关键字参数cascade可以设置这些属性:

  1. save-update:默认选项。在添加一条数据的时候,会把其他和他相关联的数据都添加到数据库中。这种行为就是save-update属性影响的。
  2. delete:表示当删除某一个模型中的数据的时候,是否也删掉使用relationship和他关联的数据。
  3. delete-orphan:表示当对一个ORM对象解除了父表中的关联对象的时候,自己便会被删除掉。当然如果父表中的数据被删除,自己也会被删除。这个选项只能用在一对多上,不能用在多对多以及多对一上。并且还需要在子模型中的relationship中,增加一个single_parent=True的参数。
  4. merge:默认选项。当在使用session.merge,合并一个对象的时候,会将使用了relationship相关联的对象也进行merge操作。
  5. expunge:移除操作的时候,会将相关联的对象也进行移除。这个操作只是从session中移除,并不会真正的从数据库中删除。
  6. all:是对save-update, merge, refresh-expire, expunge, delete几种的缩写。

排序:

  1. order_by:可以指定根据这个表中的某个字段进行排序,如果在前面加了一个-,代表的是降序排序。

  2. 在模型定义的时候指定默认排序:有些时候,不想每次在查询的时候都指定排序的方式,可以在定义模型的时候就指定排序的方式。有以下两种方式:

    • relationship的order_by参数:在指定relationship的时候,传递order_by参数来指定排序的字段。

    • 在模型定义中,添加以下代码:

       __mapper_args__ = {
           "order_by": title
         }

      即可让文章使用标题来进行排序。

  3. 正向排序和反向排序:默认情况是从小到大,从前到后排序的,如果想要反向排序,可以调用排序的字段的desc方法。

limit、offset和切片:

  1. limit:可以限制每次查询的时候只查询几条数据。
  2. offset:可以限制查找数据的时候过滤掉前面多少条。
  3. 切片:可以对Query对象使用切片操作,来获取想要的数据。

懒加载:

在一对多,或者多对多的时候,如果想要获取多的这一部分的数据的时候,往往能通过一个属性就可以全部获取了。比如有一个作者,想要或者这个作者的所有文章,那么可以通过user.articles就可以获取所有的。但有时候我们不想获取所有的数据,比如只想获取这个作者今天发表的文章,那么这时候我们可以给relationship传递一个lazy='dynamic',以后通过user.articles获取到的就不是一个列表,而是一个AppendQuery对象了。这样就可以对这个对象再进行一层过滤和排序等操作。

查询高级:

group_by:

根据某个字段进行分组。比如想要根据性别进行分组,来统计每个分组分别有多少人,那么可以使用以下代码来完成:

session.query(User.gender,func.count(User.id)).group_by(User.gender).all()

having:

having是对查找结果进一步过滤。比如只想要看未成年人的数量,那么可以首先对年龄进行分组统计人数,然后再对分组进行having过滤。示例代码如下:

result = session.query(User.age,func.count(User.id)).group_by(User.age).having(User.age >= 18).all()

join方法:

join查询分为两种,一种是inner join,另一种是outer join。默认的是inner join,如果指定left join或者是right join则为outer join。如果想要查询User及其对应的Address,则可以通过以下方式来实现:

  for u,a in session.query(User,Address).filter(User.id==Address.user_id).all():
    print u
    print a
  # 输出结果:
  > <User (id=1,name='ed',fullname='Ed Jason',password='123456')>
  > <Address id=4,email=ed@google.com,user_id=1>

这是通过普通方式的实现,也可以通过join的方式实现,更加简单:

  for u,a in session.query(User,Address).join(Address).all():
    print u
    print a
  # 输出结果:
  > <User (id=1,name='ed',fullname='Ed Jason',password='123456')>
  > <Address id=4,email=ed@google.com,user_id=1>

当然,如果采用outerjoin,可以获取所有user,而不用在乎这个user是否有address对象,并且outerjoin默认为左外查询:

  for instance in session.query(User,Address).outerjoin(Address).all():
    print instance
  # 输出结果:
  (<User (id=1,name='ed',fullname='Ed Jason',password='123456')>, <Address id=4,email=ed@google.com,user_id=1>)
  (<User (id=2,name='xt',fullname='xiaotuo',password='123')>, None)

别名:

当多表查询的时候,有时候同一个表要用到多次,这时候用别名就可以方便的解决命名冲突的问题了:

  from sqlalchemy.orm import aliased
  adalias1 = aliased(Address)
  adalias2 = aliased(Address)
  for username,email1,email2 in session.query(User.name,adalias1.email_address,adalias2.email_address).join(adalias1).join(adalias2).all():
    print username,email1,email2

子查询:

sqlalchemy也支持子查询,比如现在要查找一个用户的用户名以及该用户的邮箱地址数量。要满足这个需求,可以在子查询中找到所有用户的邮箱数(通过group by合并同一用户),然后再将结果放在父查询中进行使用:

  from sqlalchemy.sql import func
  # 构造子查询
  stmt = session.query(Address.user_id.label('user_id'),func.count(*).label('address_count')).group_by(Address.user_id).subquery()
  # 将子查询放到父查询中
  for u,count in session.query(User,stmt.c.address_count).outerjoin(stmt,User.id==stmt.c.user_id).order_by(User.id):
    print u,count

从上面我们可以看到,一个查询如果想要变为子查询,则是通过subquery()方法实现,变成子查询后,通过子查询.c属性来访问查询出来的列。以上方式只能查询某个对象的具体字段,如果要查找整个实体,则需要通过aliased方法,示例如下:

  stmt = session.query(Address)
  adalias = aliased(Address,stmt)
  for user,address in session.query(User,stmt).join(stmt,User.addresses):
    print user,address
最后修改:2020年7月13日 08:59