之前我們的用戶表稱為users，現在我們再建立一張被稱為addresses的表用于存儲電子郵件地址，通過Declarative系統，我們可以直接用映射類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

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

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

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

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

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

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

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

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

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

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

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

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

最后我們需要在數據庫中創建addresses表，所以我們需要通過元數據(metadata)執行我們的CREATE語句，當然會跳過我們已經創建的表(比如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關系算是建立完成了，接下來開始新的一部分，就是如何查詢關聯的對象。

現在如果我們創建一個User，一個空的addresses集合將會被創建，在這里默認情況下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]

 
>>> jack.addresses[1].user

讓我們添加并提交Jack Bean到數據庫中，現在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語句執行：

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

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

>>> 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,)
[, ]

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

聲明：本網頁內容旨在傳播知識，若有侵權等問題請及時與本網聯系，我們將在第一時間刪除處理。TEL:177 7030 7066 E-MAIL:11247931@qq.com