对象关系教程ORM-连接

一：内连接

方法一：

for u, a in session.query(User, Address).\

                    filter(User.id==Address.user_id).\

                     filter(Address.email_address=='jack@google.com').\

                     all():

     print(u)

     print(a)

方法二：

session.query(User).join(Address).\

        filter(Address.email_address=='jack@google.com').\

        all()

　　Query.join()知道如何加入之间 User和 Address因为他们之间只有一个外键

二：左连接

query.outerjoin(User.addresses)# LEFT OUTER JOIN

三：使用别名

　　跨多个表查询时,如果相同的表需要不止一次引用,表的SQL通常需要与另一个名称别名,这样它就可以被区分与其他表的出现。的 Query支持这个最显式地使用 aliased构造。下面我们加入的 Address实体两次,来定位用户在同一时间有两个不同的电子邮件地址

>>> from sqlalchemy.orm import aliased

>>> adalias1 = aliased(Address)

>>> adalias2 = aliased(Address)

SQL>>> for username, email1, email2 in \

...     session.query(User.name, adalias1.email_address, adalias2.email_address).\

...     join(adalias1, User.addresses).\

...     join(adalias2, User.addresses).\

...     filter(adalias1.email_address=='jack@google.com').\

...     filter(adalias2.email_address=='j25@yahoo.com'):

...     print(username, email1, email2)

四：使用子查询

　Query适用于生成报表,可以用作子查询。假设我们想负载 User对象数的多少 Address每个用户都有记录。生成SQL的最好方法是获取地址分组的用户id,并加入到父。在本例中,我们使用一个左外连接,这样我们拿回行对于那些用户没有任何地址

使用 Query,我们建立一个这样的声明由内而外。的 statement访问器返回一个代表声明由一个特定的SQL表达式 Query——这是一个实例 select()构造,中描述SQL表达式语言教程:

的 func关键字生成SQL函数, subquery()方法 Query生成一个SQL表达式构造代表一个SELECT语句嵌入一个别名(实际上是缩写query.statement.alias()).

一旦我们有声明,它像一个 Table构造,如我们创建的 users在本教程的开始。声明可通过一个属性的列 c:

SELECT users.*, adr_count.address_count FROM users LEFT OUTER JOIN

    (SELECT user_id, count(*) AS address_count

        FROM addresses GROUP BY user_id) AS adr_count

    ON users.id=adr_count.user_id

from sqlalchemy.sql import func

>>> stmt = session.query(Address.user_id, func.count('*').\

...         label('address_count')).\

...         group_by(Address.user_id).subquery()

>>> from sqlalchemy.sql import func

>>> stmt = session.query(Address.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)

五：从子查询选择实体

>>> stmt = session.query(Address).\

...                 filter(Address.email_address != 'j25@yahoo.com').\

...                 subquery()

>>> adalias = aliased(Address, stmt)

>>> for user, address in session.query(User, adalias).\

...         join(adalias, User.addresses):

...     print(user)

...     print(address)

六：使用存在

在SQL中存在关键字是一个布尔操作符,返回True,如果给定的表达式包含任何行。也许在很多场景中使用的连接,也用于定位行,没有一个相关的表中相应的行。

存在一个显式构造,它看起来像这样:

>>> from sqlalchemy.sql import exists

>>> stmt = exists().where(Address.user_id==User.id)

SQL>>> for name, in session.query(User.name).filter(stmt):

...     print(name)

　　Query自动功能使多个运算符使用存在。以上,声明可以表达的 User.addresses使用的关系 any():

>>> for name, in session.query(User.name).\

...         filter(User.addresses.any()):

...     print(name)

has()运营商一样吗 any()多对一的关系(注意 ~运营商,这意味着“不”):

>>>session.query(Address).\

...filter(~Address.user.has(User.name=='jack')).all()[]

七：常见的关系操作符

这是所有的运营商建立关系,每一个与它的API文档包括使用详情和行为:

__eq__()(多对一的“=”比较):
```
query.filter(Address.user==someuser)
```
__ne__()(多对一的“不等于”比较):
```
query.filter(Address.user!=someuser)
```
为空(多对一的比较,还使用吗 __eq__()):
```
query.filter(Address.user==None)
```

contains()(用于一对多收藏):

query.filter(User.addresses.contains(someaddress))

any()(用于收藏):

query.filter(User.addresses.any(Address.email_address=='bar'))# also takes keyword arguments:query.filter(User.addresses.any(email_address='bar'))

has()(用于标量引用):

query.filter(Address.user.has(name='ed'))

Query.with_parent()(用于任何关系):

session.query(Address).with_parent(someuser,'addresses')

删除

session.delete(jack)

session.query(User).filter_by(name='jack').count()

级联删除

 class User(Base):

...     __tablename__ = 'users'

...

...     id = Column(Integer, primary_key=True)

...     name = Column(String)

...     fullname = Column(String)

...     password = Column(String)

...

...     addresses = relationship("Address", back_populates='user',

...                     cascade="all, delete, delete-orphan")

...

...     def __repr__(self):

...        return "<User(name='%s', fullname='%s', password='%s')>" % (

...                                self.name, self.fullname, self.password)

巴特西

SQLAlchemy-对象关系教程ORM-连接，子查询