前面介紹了關于用戶賬戶的User表，但是現(xiàn)實生活中隨著問題的復雜化數(shù)據(jù)庫存儲的數(shù)據(jù)不可能這么簡單，讓我們設想有另外一張表，這張表和User有聯(lián)系，也能夠被映射和查詢，那么這張表可以存儲關聯(lián)某一賬戶的任意數(shù)量的電子郵件地址。這種聯(lián)系在數(shù)據(jù)庫理論中是典型的1-N (一對多)關系，用戶表某一用戶對應N條電子郵件記錄。

之前我們的用戶表稱為users，現(xiàn)在我們再建立一張被稱為addresses的表用于存儲電子郵件地址，通過Declarative系統(tǒng)，我們可以直接用映射類Address來定義這張表：

>>> from sqlalchemy import ForeignKey
>>> from sqlalchemy.orm import 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 __init__(self, email_address):
...     self.email_address = email_address
...
...   def __repr__(self):
...     return "〈Address('%s')〉" % self.email_address

讓我們注意一下新出現(xiàn)的東東，首先就是user_id的ForeignKey結構，學過數(shù)據(jù)庫的同學都知道ForeignKey意味著外鍵，這是關系型數(shù)據(jù)庫的核心理論之一，即該列user_id與其外鍵引用的列users.id存在引用約束(constrained)關系，在數(shù)據(jù)庫層面上來講，就是表users的user_id列被表users的id列約束，值得注意的是，外鍵關聯(lián)的必定是另外一張表的主鍵。

其次新出現(xiàn)的就是relationship()函數(shù)，這個將會告知ORM通過Address.userAddress類自身必須鏈接到User類。relationship()使用兩個表的外鍵約束來判定這種鏈接的性質，比如說判定Address.user將會是多對一(many-to-one)關系。

另外在relationship()內還有另外一個函數(shù)稱為backref()，它將提供一種用于反向查詢的細節(jié)，比如說在對象User上的Address對象集是通過User.addresses屬性引用，那么多對一的關系(many-to-one)反向總會是一對多關系(one-to-many)。還有對于Address.user和User.addresses的關系來說總是雙向的。

假設使用了Declarative系統(tǒng)，那么relationship()的關系到遠端類(remote class)的參數(shù)能夠被指定為字符串。一旦所有的映射都被成功加載，那么這些字符串將會被計算出Python的表達式，再產生實際的參數(shù)(上文中User類的情況)。這些可以使用的字符串名字必須通過定義的基類創(chuàng)建好然后才被計算為實際的類參數(shù)，說白了，你字符串引用的類必須是ORM映射管理的類，然后這些類被映射完畢后，這些字符串才能被真正翻譯為相應類的引用。

接下來我們舉個例子同樣創(chuàng)建用User取代Address的”addresses/user”雙向關系：

class User(Base):
  # ....
  addresses = relationship("Address", order_by="Address.id", backref="user")

好吧，剛才多是直接翻譯的官方文檔，比較生硬，接下來我們來了解幾個關于外鍵(Foreign Key)的小知識：

1. FOREIGN KEY 約束是大多數(shù)(但不是所有)的關系型數(shù)據(jù)庫中可以鏈接到主鍵列，或者擁有UNIQUE約束的列。

2. FOREIGN KEY 能夠引用多重列主鍵，并且其自身擁有多重列，被稱為“復合外鍵”(composite foreign key)。其也能夠引用這些列的子集(subset)。(注：這地方不太明白)

3. FOREIGN KEY 列作為對于其引用的列或者行的變化的響應能夠自動更新其自身，比如CASCADE引用操作，這些都是內置于關系型數(shù)據(jù)庫的功能之一。

4. FOREIGN KEY 能夠引用其自身的表，這個就涉及到“自引用”(self-referential)的外鍵了。

5. 更多關于外鍵的資料可以參考Foreign Key – Wikipedia。

最后我們需要在數(shù)據(jù)庫中創(chuàng)建addresses表，所以我們需要通過元數(shù)據(jù)(metadata)執(zhí)行我們的CREATE語句，當然會跳過我們已經創(chuàng)建的表(比如users)：

>>> Base.metadata.create_all(engine) 
PRAGMA table_info("users")
()
PRAGMA table_info("addresses")
()
CREATE TABLE addresses (
  id INTEGER NOT NULL,
  email_address VARCHAR NOT NULL,
  user_id INTEGER,
  PRIMARY KEY (id),
   FOREIGN KEY(user_id) REFERENCES users (id)
)
()
COMMIT

到這里我們的ORM關系算是建立完成了，接下來開始新的一部分，就是如何查詢關聯(lián)的對象。

現(xiàn)在如果我們創(chuàng)建一個User，一個空的addresses集合將會被創(chuàng)建，在這里默認情況下addresses集合將會是列表類型。

>>> jack = User('jack', 'Jack Bean', 'gjffdd')
>>> jack.addresses
[]

接下來我們可以自由的添加Address對象到我們的User對象里了，在這里我們直接賦予addresses屬性一個完整的列表。

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

當我們使用雙向關系時，有一點需要注意的是：在任意一端添加的元素將會自動在另外一端可見，屬性的獲取和改變將不通過任何SQL語句和Python對象使用一樣：

>>> jack.addresses[1]
<Address('j25@yahoo.com')>
 
>>> jack.addresses[1].user
<User('jack','Jack Bean', 'gjffdd')>

讓我們添加并提交Jack Bean到數(shù)據(jù)庫中，現(xiàn)在jack對象的addresses集合擁有了兩個Address成員，它們將立即被加入會話中：

>>> session.add(jack)
>>> session.commit()
INSERT INTO users (name, fullname, password) VALUES (?, ?, ?)
('jack', 'Jack Bean', 'gjffdd')
INSERT INTO addresses (email_address, user_id) VALUES (?, ?)
('jack@google.com', 5)
INSERT INTO addresses (email_address, user_id) VALUES (?, ?)
('j25@yahoo.com', 5)
COMMIT

我們來查詢關于Jack的信息，但是奇怪的是沒有任何關于addresses的SQL語句執(zhí)行：

>>> jack = session.query(User).\
... filter_by(name='jack').one() 
BEGIN (implicit)
SELECT users.id AS users_id,
    users.name AS users_name,
    users.fullname AS users_fullname,
    users.password AS users_password
FROM users
WHERE users.name = ?
('jack',)
>>> jack
<User('jack','Jack Bean', 'gjffdd')>

讓我們直接來查詢addresses集合吧，這里大家看到有關addresses的SQL語句執(zhí)行了：

>>> jack.addresses 
SELECT addresses.id AS addresses_id,
    addresses.email_address AS
    addresses_email_address,
    addresses.user_id AS addresses_user_id
FROM addresses
WHERE ? = addresses.user_id ORDER BY addresses.id
(5,)
[<Address('jack@google.com')>, <Address('j25@yahoo.com')>]

由上可知，當我們訪問addresses集合的時候，相關SQL語句才被執(zhí)行，這也是延遲加載關系(惰性加載關系, lazy loading relationship)的例子，至此addresses集合方被作為普通列表加載了。

最新評論