SQLAlchemy ORM教程之三：Relationship
建立關系
之前我們已經建立了一個用戶(User)表，現在我們來考慮增加一個與用戶關聯的新的表。在我們的系統里面，用戶可以存儲多個與之相關的email地址。這是一種基本的一對多的關系。我們把這個新增加的存儲email地址的表稱為addresses。應用Declarative，我們按照如下方式定義這個新表：
>>> from sqlalchemy import ForeignKey >>> from sqlalchemy.orm import relationship>>> 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", back_populates="addresses") ... ... def __repr__(self): ... return "<Address(email_address='%s')>" % self.email_address>>> User.addresses = relationship( ... "Address", order_by=Address.id, back_populates="user")上面的代碼中我們使用了一個新的名為ForeignKey的構造。其含義為，其所在的列的值域應當被限制在另一個表的指定列的取值范圍之類。這一特性是關系型數據庫的核心特性之一。就上例而言，addresses.user_id這一列的取值范圍，應當包含在users.id的取值范圍之內。
除了ForeignKey之外，我們還引入了一個relationship，來告訴ORM，Address類需要被連接到User類。relationship和ForeignKey這個兩個屬性決定了表之間關系的屬性，決定了這個關系是多對一的。
在完成對Address類的聲明之后，我們還定義另一個relationship，將其賦值給了User.addresses。在兩個relationship中，我們都有傳入了一個relationship.back_populates的屬性來為反向關系所對應的屬性進行命名。（作者：到這里為止，看來SQLAlchemy中定義關系要比Django的ORM要麻煩許多。Django中只需要一行就可以了。而且這里的兩個relationship的定義明顯是冗余的）
多對一的關系的反向永遠都是一對多的關系。關于更多的relationship()的配置方法，可以參見這個鏈接Basic Relationship Patterns。
上述我們定義的兩個互補的關系Address.user和User.addresses被稱為雙向關系(bidirectional relationship)，這是SQLAlchemy的核心特性這一。
relationship()的參數配置中指向被連接的類的字符串，可以指向工程中任何位置所定義的，基于declarative base的類，而無先后之分。Declarative會在完成所有的映射以后的將這些字符串轉換為適當的、實際使用的參數形式。
?
使用關聯對象
現在，當我們創建一個User實例的時候，會同時創建一個空的addresses的collection。這個collection可能是多種類型，如list, set, 或是dictionary。默認情況下，其應當為一個Python列表。
>>> jack = User(name='jack', fullname='Jack Bean', password='gjffdd') >>> jack.addresses []此時你可以自由的向這個列表里面插入User對象。
>>> jack.addresses = [ ... Address(email_address='jack@google.com'), ... Address(email_address='j25@yahoo.com')]當使用bidirectional relationship時，通過其中一個方向的關系（如上例）會自動出現在另一個方向的關系上。
>>> jack.addresses[1] <Address(email_address='j25@yahoo.com')>>>> jack.addresses[1].user <User(name='jack', fullname='Jack Bean', password='gjffdd')>讓我們把jack添加進入Session。
>>> 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可以發現上面執行了三個INSERT命令，也就是說與jack關聯的兩個Address對象也被提交了。現在我們通過查詢來取出jack。
>>> 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(name='jack', fullname='Jack Bean', password='gjffdd')>可以發現目前只有針對User表的查詢，而沒有對Address表的查詢。此時訪問addresses屬性，相關的SQL才會執行
>>> jack.addresses SELECT addresses.id AS addresses_id,addresses.email_address ASaddresses_email_address,addresses.user_id AS addresses_user_id FROM addresses WHERE ? = addresses.user_id ORDER BY addresses.id (5,) [<Address(email_address='jack@google.com')>, <Address(email_address='j25@yahoo.com')>]上面這種方式我們稱之為lazy loading。
?
使用join進行查詢
現在我們有了兩會在那個彼此關聯的數據表了，相比與上一篇教程中的簡單查詢情況，此時試圖對這兩張表進行聯合查詢就更加復雜一些了。關于join技術，讀者可以自行閱讀我的前一篇文章。
為了在User和Address之間構造一個簡單的join，我們可以通過Query.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='Jack Bean', password='gjffdd')> <Address(email_address='jack@google.com')>而實際的SQL JOIN語法，可以通過Query.join()來想實現
>>> session.query(User).join(Address).\ ... filter(Address.email_address=='jack@google.com').\ ... all() users.id AS users_id,users.name AS users_name,users.fullname AS users_fullname,users.password AS users_password FROM users JOIN addresses ON users.id = addresses.user_id WHERE addresses.email_address = ? ('jack@google.com',) [<User(name='jack', fullname='Jack Bean', password='gjffdd')>]在上面的例子中由于只存在一個ForeignKey，Query.join知道如何選取合適的列進行JOIN。如果沒有定義ForeignKey，或者存在多個，此時你需要手動指明你參與JOIN的列。Query.join()以如下方式進行：
query.join(Address, User.id==Address.user_id) # explicit condition query.join(User.addresses) # specify relationship from left to right query.join(Address, User.addresses) # same, with explicit target query.join('addresses')對于OUTER JOIN，只需要使用Query.outerjoin()就可以了。
query.outerjoin(User.addresses) # LEFT OUTER JOIN關于join()更為詳細的用法，還是請參考官方的文檔join
?
使用Aliases
當你的查詢涉及多個表，而其中同一個表出現了多次時，你需要的為重復的表aliase一個新的名字來避免沖突。這個功能其實我們在上一篇文章里面也提到過，下面是關于aliased的一個例子：
>>> from sqlalchemy.orm import 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) SELECT users.name AS users_name,addresses_1.email_address AS addresses_1_email_address,addresses_2.email_address AS addresses_2_email_address FROM users JOIN addresses AS addresses_1ON users.id = addresses_1.user_id JOIN addresses AS addresses_2ON users.id = addresses_2.user_id WHERE addresses_1.email_address = ?AND addresses_2.email_address = ? ('jack@google.com', 'j25@yahoo.com') jack jack@google.com j25@yahoo.com使用子查詢(Subqueries)
Query適合于用來構造子查詢。假如我們想要取出User記錄，并且同時計算各個用戶的Address的數量。產生這種功能的SQL指令最好的辦法是按照user的id分組統計地址的數量，然后join到外層查詢。此時我們需要LEFT JOIN，這樣可以使得沒有地址的用戶也會出現在查詢結果中（地址數量為0）。 我們期望的SQL命令是這樣的：
SELECT users.*, adr_count.address_count FROM users LEFT OUTER JOIN(SELECT user_id, count(*) AS address_countFROM addresses GROUP BY user_id) AS adr_countON users.id=adr_count.user_id使用Query，我們可以從內到外來構造上面的語句。
>>> from sqlalchemy.sql import func >>> stmt = session.query(Address.user_id, func.count('*').\ ... label('address_count')).\ ... group_by(Address.user_id).subquery()func我們已經在之前的教程中認識過了。subquery()可以產生一個內嵌了alias（是一個query.statement.alias()）的查詢(SELECT)語句的表達。
當我們生成了statement之后，其完全可以視為一個Table來使用。你可以通過c來訪問它的屬性。
>>> 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) SELECT users.id AS users_id,users.name AS users_name,users.fullname AS users_fullname,users.password AS users_password,anon_1.address_count AS anon_1_address_count FROM users LEFT OUTER JOIN(SELECT addresses.user_id AS user_id, count(?) AS address_countFROM addresses GROUP BY addresses.user_id) AS anon_1ON users.id = anon_1.user_id ORDER BY users.id ('*',) <User(name='ed', fullname='Ed Jones', 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從子查詢中取出Entity
在前一個例子中，我們從子查詢活著的是一個臨時性的JOIN后的表，但是這個表并未定義我們在ORM中定義的Entity。如果我們想將這個臨時表映射到ORM中的類呢？此時我們可以使用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) SELECT users.id AS users_id,users.name AS users_name,users.fullname AS users_fullname,users.password AS users_password,anon_1.id AS anon_1_id,anon_1.email_address AS anon_1_email_address,anon_1.user_id AS anon_1_user_id FROM users JOIN(SELECT addresses.id AS id,addresses.email_address AS email_address,addresses.user_id AS user_idFROM addressesWHERE addresses.email_address != ?) AS anon_1ON users.id = anon_1.user_id ('j25@yahoo.com',) <User(name='jack', fullname='Jack Bean', password='gjffdd')> <Address(email_address='jack@google.com')>使用EXISTS
EXISTS關鍵字是一個BOOL型操作符。當查詢結果存在至少一行時返回True。EXISTS可以常常和JOIN搭配使用。
下面是一個顯式的EXISTS構造方法：
>>> from sqlalchemy.sql import exists >>> stmt = exists().where(Address.user_id==User.id) >>> for name, in session.query(User.name).filter(stmt): ... print(name) SELECT users.name AS users_name FROM users WHERE EXISTS (SELECT * FROM addresses WHERE addresses.user_id = users.id) () jackQuery還定義了若干個自動使用了EXISTS的操作。上面的例子可以用any()來完成：
>>> for name, in session.query(User.name).\ ... filter(User.addresses.any()): ... print(name) SELECT users.name AS users_name FROM users WHERE EXISTS (SELECT 1 FROM addresses WHERE users.id = addresses.user_id) () jackany()也接受篩選條件來限制匹配的行：
>>> for name, in session.query(User.name).\ ... filter(User.addresses.any(Address.email_address.like('%google%'))): ... print(name) jackhas()對于的many-to-one的關系，起到的是和any()同樣的作用（注意這里~表示NOT）：
>>> session.query(Address).\ ... filter(~Address.user.has(User.name=='jack')).all() []常用的關系操作
下面只是簡單的列出了一些常用的操作。想要更為詳細的了解這些功能，還是推薦去官網的相關文檔。
- eq() (many-to-one “equals” comparison):
- ne() (many-to-one “not equals” comparison):
- IS NULL (many-to-one comparison, also uses eq()):
- contains() (used for one-to-many collections):
- any() (used for collections):
- has() (used for scalar references):
- Query.with_parent() (used for any relationship):
?
Eager Loading（找不到合適的翻譯）
前面的教程中我們有提及到lazing loading的機制。當我們通過查詢取出用戶時，與之關聯的地址并沒有取出來。當我們試圖獲取User.addresses時，相關的針對地址的SQL查詢才起作用。如果你想要減少query的次數的話，就需要使用Eager Loading了。SQLAlchemy提供了三種Eager Loading的方式，其中兩種是自動的，而第三種涉及到自定義的篩選條件。所有的這三種Eager Loading方式都會通過調用Query.options()來影響查詢的過程，促使Query生成需要的額外配置來取出期望的內容。
Subquery Loading
在上面的例子中，我們希望在 取出用戶的時候就同步取出對應的地址。此時你們可以此采用orm.subqueryload()。這個函數可以發起第二個SELECT查詢來取出與結果相關的另一個表的信息。這里取名為"subquery"的原因是，此處的Query在發起第二個查詢時作為子查詢而被復用了。詳細過程參加下面的程序：
>>> from sqlalchemy.orm import subqueryload >>> jack = session.query(User).\ ... options(subqueryload(User.addresses)).\ ... filter_by(name='jack').one() 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',) SELECT addresses.id AS addresses_id,addresses.email_address AS addresses_email_address,addresses.user_id AS addresses_user_id,anon_1.users_id AS anon_1_users_id FROM (SELECT users.id AS users_idFROM users WHERE users.name = ?) AS anon_1 JOIN addresses ON anon_1.users_id = addresses.user_id ORDER BY anon_1.users_id, addresses.id ('jack',) >>> jack <User(name='jack', fullname='Jack Bean', password='gjffdd')>>>> jack.addresses [<Address(email_address='jack@google.com')>, <Address(email_address='j25@yahoo.com')>]注意：當subqueryload()和涉及limiting的函數一起使用的時候（如Query.first(), Query.limit(), Query.offset()等），應當加上一個以Unique的行作為參數的Query.order_by()`來確保結果的正確性。詳情參見The importance of Ordering
Joined Load
這種自動Eager Loading的方式要更為常用一些。Joined Loading發起了一個JOIN（默認是LEFT OUTER JOIN），故而查詢結果和制定的與之關聯的行可以被同時取出。我們這里以和上面的Subquery Loading中同樣的查詢目的為例。
>>> from sqlalchemy.orm import joinedload>>> jack = session.query(User).\ ... options(joinedload(User.addresses)).\ ... filter_by(name='jack').one() SELECT users.id AS users_id,users.name AS users_name,users.fullname AS users_fullname,users.password AS users_password,addresses_1.id AS addresses_1_id,addresses_1.email_address AS addresses_1_email_address,addresses_1.user_id AS addresses_1_user_id FROM usersLEFT OUTER JOIN addresses AS addresses_1 ON users.id = addresses_1.user_id WHERE users.name = ? ORDER BY addresses_1.id ('jack',)>>> jack <User(name='jack', fullname='Jack Bean', password='gjffdd')>>>> jack.addresses [<Address(email_address='jack@google.com')>, <Address(email_address='j25@yahoo.com')>]注意到，如果你是在命令行運行了前一個Subquery Loading的例子的話，在這里jack的addresses實際上已經填充了的，但是這里的Joined Load仍然是會發起JOIN。另外，LEFT OUTER JOIN指令實際上有可能導致重復的User出現，但是在結果中實際得到的User卻不會重復。這是因為Query實際上是基于Object Identity采用了一種"uniquing"的策略。
歷史上來看joinedload()出現的更早一些。joinedloading()更加適合于處理Many-to-one的關系。
顯式的Join + EagerLoad
第三種方式我們是我們自己顯式的調用join來定位JOIN連接主鍵，并接著關聯表的信息填充到查詢結果中對應對象或者列表中。這個特性需要使用到orm.contains_eager()函數。這個機制最典型的用途是pre-loading many-to-one關系，同時添加對這個關系的篩選。我們用下面的這個例子來闡述說明上面這些比較繞的話。假設我們需要篩選出用戶的名字為jack的郵件地址，進行這個查詢的方法如下：
>>> from sqlalchemy.orm import contains_eager >>> jacks_addresses = session.query(Address).\ ... join(Address.user).\ ... filter(User.name=='jack').\ ... options(contains_eager(Address.user)).\ ... all() SELECT users.id AS users_id,users.name AS users_name,users.fullname AS users_fullname,users.password AS users_password,addresses.id AS addresses_id,addresses.email_address AS addresses_email_address,addresses.user_id AS addresses_user_id FROM addresses JOIN users ON users.id = addresses.user_id WHERE users.name = ? ('jack',)>>> jacks_addresses [<Address(email_address='jack@google.com')>, <Address(email_address='j25@yahoo.com')>]>>> jacks_addresses[0].user <User(name='jack', fullname='Jack Bean', password='gjffdd')>?
關系中的刪除問題
沃恩嘗試刪除jack，來看結果：
>>> session.delete(jack) >>> session.query(User).filter_by(name='jack').count() UPDATE addresses SET user_id=? WHERE addresses.id = ? ((None, 1), (None, 2)) DELETE FROM users WHERE users.id = ? (5,) SELECT count(*) AS count_1 FROM (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 = ?) AS anon_1 ('jack',) 0那么與jack關聯的地址呢？
>>> session.query(Address).filter( ... Address.email_address.in_(['jack@google.com', 'j25@yahoo.com']) ... ).count() 2地址記錄仍然在這里。如果我們commit的話，我們可以從上面的SQL語句中發現，相關的Address的user_id屬性被設置成了NULL。這不符合我們的要求。那么我們需要自己來設置關系的刪除規則。
?
配置delete/delete-orphan Cascade
我們通過配置User.addresses關系的cascade*選項來控制刪除行為。盡管SQLAlchemy允許你在任何時候給ORM添加屬性或者關系。此時我們還是需要移除現存的關系并且重新開始（作者：django的ORM包含）。讓我們首先關閉當前的session
>>> session.close()并且使用一個新的declarative_base():
>>> Base = declarative_base()下面我們重新聲明User類，注意addresses中的配置：
>>> class User(Base): ... __tablename__ = 'users' ... ... id = Column(Integer, primary_key=True) ... name = Column(String) ... fullname = Column(String) ... password = Column(String) ... ... addresses = relationship("Address", back_populates='user', ... cascade="all, delete, delete-orphan") ... ... def __repr__(self): ... return "<User(name='%s', fullname='%s', password='%s')>" % ( ... self.name, self.fullname, self.password)接下來重新聲明Address。
>>> 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", back_populates="addresses") ... ... def __repr__(self): ... return "<Address(email_address='%s')>" % self.email_address現在讓我們取出jack(下面我們使用了一個之前沒有提到的函數get()，其參數為查詢目標的主鍵)，現在從addresses中刪除一個地址的話，會導致這個Address被刪除。
# load Jack by primary key SQL>>> jack = session.query(User).get(5)# remove one Address (lazy load fires off) SQL>>> del jack.addresses[1]# only one address remains SQL>>> session.query(Address).filter( ... Address.email_address.in_(['jack@google.com', 'j25@yahoo.com']) ... ).count() 1刪除jack也會導致剩下jack以及其所有的Address都會被刪除:
>> session.delete(jack)SQL>>> session.query(User).filter_by(name='jack').count() 0SQL>>> session.query(Address).filter( ... Address.email_address.in_(['jack@google.com', 'j25@yahoo.com']) ... ).count() 0關于更多的Cascade配置請參見官方文檔。
?
建立多對多關系ManyToMany Relationship
現在我們需要引入一個新的模型來闡述多對多的關系了。假設我們需要完成一個博客應用。在這個應用里面我們可以書寫BlogPost，每個博客都有若干Keyword。
對于一個多對多的關系，我們需要建立一個未映射的（也就是沒有一個Python類與之對應的）表Table來作為中間聯系的表。
>>> from sqlalchemy import Table, Text >>> # association table >>> post_keywords = Table('post_keywords', Base.metadata, ... Column('post_id', ForeignKey('posts.id'), primary_key=True), ... Column('keyword_id', ForeignKey('keywords.id'), primary_key=True) ... )不同于我們之前的典型的ORM方法，在上面的代碼中我們直接聲明了一個Table，而沒有制定與之對應的Python類。Table是一個構造函數，其參數中的每個Colomn以逗號分隔。
下面我們來定義BlogPost和Keyword。我們這里需要使用relationship()在這兩個類中定義一對互補的關系，其中每個關系的都指向post_keyword這個表。
>>> class BlogPost(Base): ... __tablename__ = 'posts' ... ... id = Column(Integer, primary_key=True) ... user_id = Column(Integer, ForeignKey('users.id')) ... headline = Column(String(255), nullable=False) ... body = Column(Text) ... ... # many to many BlogPost<->Keyword ... keywords = relationship('Keyword', ... secondary=post_keywords, ... back_populates='posts') ... ... def __init__(self, headline, body, author): ... self.author = author ... self.headline = headline ... self.body = body ... ... def __repr__(self): ... return "BlogPost(%r, %r, %r)" % (self.headline, self.body, self.author)>>> class Keyword(Base): ... __tablename__ = 'keywords' ... ... id = Column(Integer, primary_key=True) ... keyword = Column(String(50), nullable=False, unique=True) ... posts = relationship('BlogPost', ... secondary=post_keywords, ... back_populates='keywords') ... ... def __init__(self, keyword): ... self.keyword = keyword在上面的定義中，我們可以發現和OneToMany關系不同，relationship()中多了一個secondary的參數，這個參數指向了中間表(原文為associated table)。這個中間表只包含了指向多對多關系兩側的表的主鍵的列。如果這個表包含了其他屬性，甚至是自身的主鍵，SQLAlchemy需要你使用另一種，稱為association object的機制來處理。
我們還希望我們的BlogPost能夠擁有一個author屬性，這個屬性指向我們先前定義的User。此時我們需要再定義一個雙向關系。由于一個作者可能擁有很多文章，我們希望訪問User.posts的時候可以加以篩選而不是載入全部的相關文章。為此我們在定義User.posts中的時候，設置lazy='dynamic'，來控制載入策略。
>>> BlogPost.author = relationship(User, back_populates="posts") >>> User.posts = relationship(BlogPost, back_populates="author", lazy="dynamic")然后讓我們來創建數據庫中對應的表
>>> Base.metadata.create_all(engine) PRAGMA... CREATE TABLE keywords (id INTEGER NOT NULL,keyword VARCHAR(50) NOT NULL,PRIMARY KEY (id),UNIQUE (keyword) ) () COMMIT CREATE TABLE posts (id INTEGER NOT NULL,user_id INTEGER,headline VARCHAR(255) NOT NULL,body TEXT,PRIMARY KEY (id),FOREIGN KEY(user_id) REFERENCES users (id) ) () COMMIT CREATE TABLE post_keywords (post_id INTEGER NOT NULL,keyword_id INTEGER NOT NULL,PRIMARY KEY (post_id, keyword_id),FOREIGN KEY(post_id) REFERENCES posts (id),FOREIGN KEY(keyword_id) REFERENCES keywords (id) ) () COMMIT多對多關系的使用方法道也沒有太大的不同之處。讓我們先來給windy添加博文。
>>> wendy = session.query(User).\ ... filter_by(name='wendy').\ ... one() >>> post = BlogPost("Wendy's Blog Post", "This is a test", wendy) >>> session.add(post)給博文添加一些關鍵字。目前數據庫里面還沒有關鍵字存在，我們創建一些：
>>> post.keywords.append(Keyword('wendy')) >>> post.keywords.append(Keyword('firstpost'))我們可以開始查詢了。先以'firstpost'為關鍵字來檢索所有的博文。我們使用any來查詢擁有關鍵詞'firstpost'的博文：
>>> session.query(BlogPost).\ ... filter(BlogPost.keywords.any(keyword='firstpost')).\ ... all() [BlogPost("Wendy's Blog Post", 'This is a test', <User(name='wendy', fullname='Wendy Williams', password='foobar')>)]如果我們希望將查詢范圍限制在wendy用戶所擁有的博文之內，
>>> session.query(BlogPost).\ ... filter(BlogPost.author==wendy).\ ... filter(BlogPost.keywords.any(keyword='firstpost')).\ ... all() SELECT posts.id AS posts_id,posts.user_id AS posts_user_id,posts.headline AS posts_headline,posts.body AS posts_body FROM posts WHERE ? = posts.user_id AND (EXISTS (SELECT 1FROM post_keywords, keywordsWHERE posts.id = post_keywords.post_idAND keywords.id = post_keywords.keyword_idAND keywords.keyword = ?)) (2, 'firstpost') [BlogPost("Wendy's Blog Post", 'This is a test', <User(name='wendy', fullname='Wendy Williams', password='foobar')>)]或者我們可以直接在wendy的posts屬性上進行查詢：
>>> wendy.posts.\ ... filter(BlogPost.keywords.any(keyword='firstpost')).\ ... all() [BlogPost("Wendy's Blog Post", 'This is a test', <User(name='wendy', fullname='Wendy Williams', password='foobar')>)]?
總結
以上是生活随笔為你收集整理的SQLAlchemy ORM教程之三：Relationship的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： searchsploit漏洞查找工具使用
- 下一篇： SQLAlchemy 教程 —— 进阶篇