研究Python的ORM架構中的SQLAlchemy庫的映射關係

前面介紹了關於使用者賬戶的User表，但是現實生活中隨著問題的複雜化資料庫儲存的資料不可能這麼簡單，讓我們設想有另外一張表，這張表和User有聯絡，也能夠被映射和查詢，那麼這張表可以儲存關聯某一賬戶的任意數量的電子郵件地址。這種聯絡在資料庫理論中是典型的1-N (一對多)關係，使用者表某一使用者對應N條電子郵件記錄。

之前我們的使用者表稱為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_passwordFROM usersWHERE 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_idFROM addressesWHERE ? = addresses.user_id ORDER BY addresses.id(5,)[, ]

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

