SQLAlchemy技术文档（中文版）（中）

10.建立联系（外键）

是时候考虑怎样映射和查询一个和Users表关联的第二张表了。假设我们系统的用户可以存储任意数量的email地址。我们需要定义一个新表Address与User相关联。

<span lang="en-US">from sqlalchemyimport ForeignKey<br><br><span lang="en-US">from sqlalchemy.ormimport relationship, backref</span></span>

<span lang="en-US">class Address(Base):</span>

<span lang="en-US">__tablename__ = ‘addresses‘</span>

<span lang="en-US">id= Column(Integer, primary_key=True)</span>

<span lang="en-US">email_address = Column(String, nullable=False)</span>

<span lang="en-US">user_id = Column(Integer, ForeignKey(‘users.id‘))</span>

<span lang="en-US">user = relationship("User", backref=backref(‘addresses‘,order_by=id))</span>

<span lang="en-US">def__repr__(self):</span>

<span lang="en-US">
return"<Address(email_address=‘%s‘)>"%self.email_address</span>

构造类和外键简单，就不过多赘述。主要说明以下relationship()函数：这个函数告诉ORM，Address类应该和User类连接起来，通过使用addresses.user。relationship()使用外键明确这两张表的关系。决定Adderess.user属性是多对一的。relationship()的子函数backref()提供表达反向关系的细节：relationship()对象的集合被User.address引用。多对一的反向关系总是一对多。更多的细节参考Basic RelRational Patterns。

这两个互补关系：Address.user和User.addresses被称为双向关系。这是SQLAlchemy ORM的一个非常关键的功能。更多关系backref的细节参见Linking Relationships with Backref。

假设声明的方法已经开始使用，relationship()中和其他类关联的参数可以通过strings指定。在上文的User类中，一旦所有映射成功，为了产生实际的参数，这些字符串会被当做Python的表达式。下面是一个在User类中创建双向联系的例子：

<span lang="en-US">class User(Base):</span>

<span lang="en-US">addresses = relationship("Address", order_by="Address.id", backref="user")</span>

一些知识：

在大多数的外键约束（尽管不是所有的）关系数据库只能链接到一个主键列，或具有唯一约束的列。

外键约束如果是指向多个列的主键，并且它本身也具有多列，这种被称为“复合外键”。

外键列可以自动更新自己来相应它所引用的行或者列。这被称为级联，是一种建立在关系数据库的功能。

外键可以参考自己的表格。这种被称为“自引”外键。

我们需要在数据库中创建一个addresses表，所以我们会创建另一个元数据，这将会跳过已经创建的表。

11.操作主外键关联的对象

现在我们已经在User类中创建了一个空的addresser集合，可变集合类型，例如set和dict，都可以用，但是默认的集合类型是list。

<span lang="en-US">jack = User(name=‘jack‘, fullname=‘Jack Bean‘, password=‘gjffdd‘)</span>

<span lang="en-US">jack.addresses</span>

<span lang="en-US">[]</span>

现在可以直接在User对象中添加Address对象。只需要指定一个完整的列表：

<span lang="en-US">jack.addresses = [Address(email_address=‘jack@google.com‘),Address(email_address=‘j25@yahoo.com‘)]</span>

当使用双向关系时，元素在一个类中被添加后便会自动在另一个类中添加。这种行为发生在<span lang="en-US">Python的更改事件属性中而不是用<span lang="en-US">SQL语句：</span></span>

<span lang="en-US">>>> jack.addresses[1]</span>

<span lang="en-US"><Address(email_address=‘j25@yahoo.com‘)></span>

<span lang="en-US">>>> jack.addresses[1].user</span>

<span lang="en-US"><User(name=‘jack‘, fullname=‘Jack Bean‘, password=‘gjffdd‘)></span>

把<span lang="en-US">jack提交到数据库中，再次查询<span lang="en-US">Jack，（<span lang="en-US">No SQL is yet issued for Jack’s addresses:）这句实在是翻译不了了，看看代码就明白是什么意思：</span></span></span>

<span lang="en-US">>>> jack = session.query(User).\<br><span lang="en-US">...</span></span>

<span lang="en-US">filter_by(name=‘jack‘).one()
</span>

<span lang="en-US">>>> jack</span>

<span lang="en-US"><User(name=‘jack‘,fullname=‘Jack Bean‘, password=‘gjffdd‘)></span>

<br>

<span lang="en-US">>>>jack.addresses 
</span>

<span lang="en-US">[<Address(email_address=‘jack@google.com‘)>,
<Address(email_address=‘j25@yahoo.com‘)>]</span>

当我们访问<span lang="en-US">uaddresses集合时，<span lang="en-US">SQL会被突然执行，这是一个延迟加载（<span lang="en-US">lazy loading）关系的典型例子。现在<span lang="en-US">addresses集合加载完成并且可以像对待普通列表一样对其进行操作。以后我们会优化这种加载方式。</span></span></span></span>

<span lang="en-US">12.使用<span lang="en-US">JOINS查询</span></span>

现在我们有了两张表，可以进行更多的查询操作，特别是怎样对两张表同时进行查询，<span lang="en-US">Wikipediapage on SQL JOIN提供了很详细的说明，其中一些我们将在这里说明。之前用<span lang="en-US">Query.filter()时，我们已经用过<span lang="en-US">JOIN了，<span lang="en-US">filter是一种简单的隐式<span lang="en-US">join：</span></span></span></span></span>

<span lang="en-US">>>>for u, a in <span lang="en-US">session.query(User, Address).filter(User.id==Address.user_id).filter(Address.email_address==‘jack@google.com‘).all():   </span></span>

<span lang="en-US">    print u</span>

<span lang="en-US">    print a</span>

<span lang="en-US"><User(name=‘jack‘,fullname=‘JackBean‘, password=‘gjffdd‘)></span>

<span lang="en-US"><Address(email_address=‘jack@google.com‘)></span>

用<span lang="en-US">Query.join()方法会更加简单：</span>

<span lang="en-US">>>>session.query(User).join(Address).\</span>

<span lang="en-US">...
    filter(Address.email_address==‘jack@google.com‘).\</span>

<span lang="en-US">...
    all() 
</span>

<span lang="en-US">[<User(name=‘jack‘,fullname=‘JackBean‘, password=‘gjffdd‘)>]</span>

<span lang="en-US">之所以<span lang="en-US">Query.join()知道怎么<span lang="en-US">join两张表是因为它们之间只有一个外键。如果两张表中没有外键或者有一个以上的外键，当下列几种形式使用的时候，<span lang="en-US">Query.join()可以表现的更好：</span></span></span></span>

<span lang="en-US">query.join(Address,<span lang="en-US">User.id==Address.user_id)<span lang="en-US"># 明确的条件</span></span></span>

<span lang="en-US">query.join(User.addresses)# 指定从左到右的关系</span>

<span lang="en-US">query.join(Address,User.addresses)    #同样，有明确的目标</span>

<span lang="en-US">query.join(‘addresses‘) # 同样，使用字符串</span>

<span lang="en-US">
outerjoin()和<span lang="en-US">join()用法相同</span></span>

<span lang="en-US">query.outerjoin(User.addresses)# LEFT OUTER JOIN</span>

<span lang="en-US">12.1使用别名</span>

当在多个表中查询时，如果同一张表需要被引用好几次，<span lang="en-US">SQL通常要求对这个表起一个别名，因此，<span lang="en-US">SQL可以区分对这个表进行的其他操作。<span lang="en-US">Query也支持别名的操作。下面我们<span lang="en-US">joinAddress实体两次，找到同时拥有两个不同<span lang="en-US">email的用户：</span></span></span></span></span>

<span lang="en-US">>>>from sqlalchemy.ormimport aliased</span>

<span lang="en-US">>>>adalias1 = aliased(Address)</span>

<span lang="en-US">>>>adalias2 = aliased(Address)</span>

<span lang="en-US">>>>for username, email1, email2 in\</span>

<span lang="en-US">...
    session.query(User.name,adalias1.email_address,adalias2.email_address).\</span>

<span lang="en-US">...
    join(adalias1, User.addresses).\</span>

<span lang="en-US">...
    join(adalias2, User.addresses).\</span>

<span lang="en-US">...
    filter(adalias1.email_address==‘jack@google.com‘).\</span>

<span lang="en-US">...
    filter(adalias2.email_address==‘j25@yahoo.com‘):</span>

<span lang="en-US">...
    print username, email1,
email2      
</span>

<span lang="en-US">jack
jack@google.com j25@yahoo.com</span>

<span lang="en-US">12.1使用子查询（暂时理解不了啊，多看代码研究吧：<span lang="en-US">(）</span></span>

<span lang="en-US">from sqlalchemy.sqlimport func</span>

<span lang="en-US">stmt = session.query(Address.user_id,func.count(‘*‘).\</span>

<span lang="en-US">...
        label(‘address_count‘)).\</span>

<span lang="en-US">...
        group_by(Address.user_id).subquery()</span>

<span lang="en-US">>>>
for u, count in session.query(User,stmt.c.address_count).\</span>

<span lang="en-US">...
    outerjoin(stmt, User.id==stmt.c.user_id).order_by(User.id):
</span>

<span id="__mceDel"><span lang="en-US">    print u, count</span></span>

<span lang="en-US"><User(name=‘ed‘,fullname=‘EdJones‘, password=‘f8s7ccs‘)>
None</span>

<span lang="en-US"><User(name=‘wendy‘,fullname=‘Wendy Williams‘, password=‘foobar‘)>
None</span>

<span lang="en-US"><User(name=‘mary‘,fullname=‘Mary Contrary‘, password=‘xxg527‘)>
None</span>

<span lang="en-US"><User(name=‘fred‘,fullname=‘Fred Flinstone‘, password=‘blah‘)>
None</span>

<span lang="en-US"><User(name=‘jack‘,fullname=‘Jack Bean‘, password=‘gjffdd‘)>
2</span>

<span lang="en-US">12.2从子查询中选择实体？</span>

上面的代码中我们只返回了包含子查询的一个列的结果。如果想要子查询映射到一个实体的话，使用<span lang="en-US">aliased()设置一个要映射类的子查询别名：</span>

<span lang="en-US">>>>
stmt = session.query(Address).\</span>

<span lang="en-US">...
     filter(Address.email_address!= ‘j25@yahoo.com‘).\</span>

<span lang="en-US">...
     subquery()</span>

<span lang="en-US">>>>
adalias = aliased(Address, stmt)
#？为什么有两个参数？</span>

<span lang="en-US">>>>
for user, address in session.query(User, adalias).\</span>

<span lang="en-US">...
        join(adalias, User.addresses): 
</span>

<span lang="en-US">...
    print user</span>

<span lang="en-US">...
    print address</span>

<span lang="en-US"><User(name=‘jack‘,fullname=‘Jack Bean‘, password=‘gjffdd‘)></span>

<span lang="en-US"><Address(email_address=‘jack@google.com‘)></span>

12.3使用EXISTS（存在？）

如果表达式返回任何行，EXISTS为真，这是一个布尔值。它可以用在jions中，也可以用来定位在一个关系表中没有相应行的情况：

<span lang="en-US">>>>from sqlalchemy.sqlimport exists</span>

<span lang="en-US">>>>
stmt = exists().where(Address.user_id==User.id)</span>

<span lang="en-US">>>>for name, in session.query(User.name).filter(stmt):<br></span>

<span lang="en-US">    print name</span>

<span lang="en-US">jack</span>

等价于：

<span lang="en-US">>>>for name, in session.query(User.name).\</span>

<span lang="en-US">...
 　　filter(User.addresses.any()):
  
</span>

<span lang="en-US">...
    print name</span>

<span lang="en-US">jack</span>

any()限制行匹配：

<span lang="en-US">>>>for name, in session.query(User.name).\</span>

<span lang="en-US">...
   
filter(User.addresses.any(Address.email_address.like(‘%google%‘))):
  
</span>

<span lang="en-US">...
    print name</span>

<span lang="en-US">jack</span>

has()和any()一样在应对多对一关系的情况下（注意“～“意味着”NOT”）

<span lang="en-US">>>> session.query(Address).\</span>

<span lang="en-US">...
        filter(~Address.user.has(User.name==‘jack‘)).all()
</span>

<span lang="en-US">[]</span>

12.4 常见的关系运算符

== ！= None 都是用在多对一中，而contains()用在一对多的集合中：

<span lang="en-US">query.filter(Address.user == someuser)</span>

<span lang="en-US">query.filter(User.addresses.contains(someaddress))</span>

Any()（用于集合中）：

<span lang="en-US">query.filter(User.addresses.any(Address.email_address == ‘bar‘))<span id="__mceDel"><span lang="en-US">#<span id="__mceDel"><span lang="en-US">also takes keyword arguments:</span></span></span></span></span>

<span lang="en-US">query.filter(User.addresses.any(email_address=‘bar‘))</span>

as()（用在标量？不在集合中）：

<span lang="en-US">query.filter(Address.user.has(name=‘ed‘))</span>

Query.with_parent()（所有关系都适用）：

<span lang="en-US">session.query(Address).with_parent(someuser,‘addresses‘)</span>

13 预先加载（跟性能有关）和lazy loading相对，建议直接查看文档吧

待补充。。。

SQLAlchemy技术文档（中文版）（中）

标签：注意   nal   布尔   password   提交   session   自己的   logs   asi