SQLAlchemy技術文檔（中文版）（中）

http://www.cnblogs.com/iwangzc/category/620910.html

10.創建聯繫（外鍵）

是時候考慮怎樣映射和查詢一個和Users表關聯的第二張表了。假設咱們系統的用戶能夠存儲任意數量的email地址。咱們須要定義一個新表Address與User相關聯。

from sqlalchemyimport ForeignKey

from sqlalchemy.ormimport relationship, backref

class Address(Base):

__tablename__ = 'addresses'

id= Column(Integer, primary_key=True)

email_address = Column(String, nullable=False)

user_id = Column(Integer, ForeignKey('users.id'))

user = relationship("User", backref=backref('addresses',order_by=id))

def__repr__(self):

	return"<Address(email_address='%s')>"%self.email_address

構造類和外鍵簡單，就不過多贅述。主要說明如下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類中建立雙向聯繫的例子：

class User(Base):

addresses = relationship("Address", order_by="Address.id", backref="user")

一些知識：

在大多數的外鍵約束（儘管不是全部的）關係數據庫只能連接到一個主鍵列，或具備惟一約束的列。

外鍵約束若是是指向多個列的主鍵，而且它自己也具備多列，這種被稱爲「複合外鍵」。

外鍵列能夠自動更新本身來相應它所引用的行或者列。這被稱爲級聯，是一種創建在關係數據庫的功能。

外鍵能夠參考本身的表格。這種被稱爲「自引」外鍵。

咱們須要在數據庫中建立一個addresses表，因此咱們會建立另外一個元數據，這將會跳過已經建立的表。

11.操做主外鍵關聯的對象

如今咱們已經在User類中建立了一個空的addresser集合，可變集合類型，例如set和dict，均可以用，可是默認的集合類型是list。

jack = User(name='jack', fullname='Jack Bean', password='gjffdd')

jack.addresses

[]

如今能夠直接在User對象中添加Address對象。只須要指定一個完整的列表：

jack.addresses = [Address(email_address='jack@google.com'),Address(email_address='j25@yahoo.com')]

當使用雙向關係時，元素在一個類中被添加後便會自動在另外一個類中添加。這種行爲發生在Python的更改事件屬性中而不是用SQL語句：

>>> jack.addresses[1]

<Address(email_address='j25@yahoo.com')>

>>> jack.addresses[1].user

<User(name='jack', fullname='Jack Bean', password='gjffdd')>

把jack提交到數據庫中，再次查詢Jack，（No SQL is yet issued for Jack’s addresses:）這句實在是翻譯不了了，看看代碼就明白是什麼意思：

>>> jack = session.query(User).\
...

filter_by(name='jack').one()

>>> jack

<User(name='jack',fullname='Jack Bean', password='gjffdd')>

>>>jack.addresses 

[<Address(email_address='jack@google.com')>,
<Address(email_address='j25@yahoo.com')>]

當咱們訪問uaddresses集合時，SQL會被忽然執行，這是一個延遲加載（lazy loading）關係的典型例子。如今addresses集合加載完成而且能夠像對待普通列表同樣對其進行操做。之後咱們會優化這種加載方式。

12.使用JOINS查詢

如今咱們有了兩張表，能夠進行更多的查詢操做，特別是怎樣對兩張表同時進行查詢，Wikipediapage on SQL JOIN提供了很詳細的說明，其中一些咱們將在這裏說明。以前用Query.filter()時，咱們已經用過JOIN了，filter是一種簡單的隱式join：

>>>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

<User(name='jack',fullname='JackBean', password='gjffdd')>

<Address(email_address='jack@google.com')>

用Query.join()方法會更加簡單：

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

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

...
    all() 

[<User(name='jack',fullname='JackBean', password='gjffdd')>]

之因此Query.join()知道怎麼join兩張表是由於它們之間只有一個外鍵。若是兩張表中沒有外鍵或者有一個以上的外鍵，當下列幾種形式使用的時候，Query.join()能夠表現的更好：

query.join(Address,User.id==Address.user_id)# 明確的條件

query.join(User.addresses)# 指定從左到右的關係

query.join(Address,User.addresses)    #一樣，有明確的目標

query.join('addresses') # 一樣，使用字符串

	outerjoin()和join()用法相同

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

12.1使用別名

當在多個表中查詢時，若是同一張表須要被引用好幾回，SQL一般要求對這個表起一個別名，所以，SQL能夠區分對這個表進行的其餘操做。Query也支持別名的操做。下面咱們joinAddress實體兩次，找到同時擁有兩個不一樣email的用戶：

>>>from sqlalchemy.ormimport aliased

>>>adalias1 = aliased(Address)

>>>adalias2 = aliased(Address)

>>>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      

jack
jack@google.com j25@yahoo.com

12.1使用子查詢（暫時理解不了啊，多看代碼研究吧：(）

from sqlalchemy.sqlimport 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

<User(name='ed',fullname='EdJones', password='f8s7ccs')>
None

<User(name='wendy',fullname='Wendy Williams', password='foobar')>
None

<User(name='mary',fullname='Mary Contrary', password='xxg527')>
None

<User(name='fred',fullname='Fred Flinstone', password='blah')>
None

<User(name='jack',fullname='Jack Bean', password='gjffdd')>
2

12.2從子查詢中選擇實體？

上面的代碼中咱們只返回了包含子查詢的一個列的結果。若是想要子查詢映射到一個實體的話，使用aliased()設置一個要映射類的子查詢別名：

>>>
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

<User(name='jack',fullname='Jack Bean', password='gjffdd')>

<Address(email_address='jack@google.com')>

12.3使用EXISTS（存在？）

若是表達式返回任何行，EXISTS爲真，這是一個布爾值。它能夠用在jions中，也能夠用來定位在一個關係表中沒有相應行的狀況：

>>>from sqlalchemy.sqlimport exists

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

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

    print name

jack

等價於：

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

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

...
    print name

jack

any()限制行匹配：

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

...
   
filter(User.addresses.any(Address.email_address.like('%google%'))):
  

...
    print name

jack

has()和any()同樣在應對多對一關係的狀況下（注意「～「意味着」NOT」）

>>> session.query(Address).\

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

[]

12.4 常見的關係運算符

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

query.filter(Address.user == someuser)

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'))

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

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

Query.with_parent()（全部關係都適用）：

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

13 預先加載（跟性能有關）和lazy loading相對，建議直接查看文檔吧

待補充。。。