Flask實作_ext_02_Flask-SQLAlchemy_關聯

tags: `flask` `flask_ext` `python` `SQLAlchemy`

官方文件：

在Flask實作_ext_01_Flask-SQLAchemy_初探中，我們瞭解到如何透過類別的建置來產生表單，此篇主要討論資料表之間的關聯設置。
關聯式資料庫中，不外乎一對一、一對多、多對一與多對多的關聯方式，關聯的設置影響到我們對物件的操作，老話一句，需求推動功能，先瞭解基本，有進階需求的時候自然會尋找答案，另外，flask-sqlalchemy的官方文件對幾種關聯方式都有案例，如果臨時想不到如何設置的時候記得查詢官方文件_{如官方文件Declaring Models}。

範例

範例_一對多

我們利用上一篇的範例來做調整，如下修正：








































from flask import Flask
#  from flask.ext.sqlalchemy import SQLAlchemy<--新版取消了
from flask_sqlalchemy import SQLAlchemy
import os

#  取得目前文件資料夾路徑
pjdir = os.path.abspath(os.path.dirname(__file__))

app = Flask(__name__)
#  新版本的部份預設為none，會有異常，再設置True即可。
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
#  設置sqlite檔案路徑
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + \
    os.path.join(pjdir, 'data.sqlite')

db = SQLAlchemy(app)

class User(db.Model):
    __tablename__ = 'users'
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True, nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)
    #  設置關聯，relationship設置於一對多的『一』
    contacts = db.relationship('Contact', backref='user')

    def __repr__(self):
        return '<User %r>' % self.username

class Contact(db.Model):
    __tablename__ = 'contacts'
    id = db.Column(db.Integer, primary_key=True)
    contact_style = db.Column(db.String)
    contact_context = db.Column(db.String)
    #  設置外來鍵，ForeignKey設置於一對多的『多』
    user_id = db.Column(db.Integer, db.ForeignKey('users.id'))

    
    def __repr__(self):
        return 'contact_style:%s, contact_context:%s' % \
            (self.contact_style, self.contact_context)

SQLAlchemy中，每個Model都要求要設置主鍵，名稱通常設置為id

範例中設置了兩個類別，一個使用者(User)，一個聯絡方式(Contact)，在寫程式的時候我會特別註記好設置關聯的那一方是『一對多的一或一對多的多』，透過兩邊的設置讓SQLAlchemy瞭解關聯的關係。

在Python Shell中執行db.create_all()之後，可以透過sqlite圖形介面查看，已經確實的產生了兩個Table，如下圖：


    contacts = db.relationship('Contact', backref='user')

db.relationship，透過關聯設置讓人家知道Contact跟User相愛，兩個人之間恩愛透過backref來連接關係。_{(也可以透過back_populates設置)}不過實際上這是一個在雙方都設置監聽器的作法，透過db.relationship讓SQLAlchemy知道Contact跟User是有關聯的，但前提是必需設置ForeignKey，更深入的說明可參閱參考文件中Relationships-backref


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

db.ForeignKey可很以直觀的以資料庫的角度去看，這代表我們在保存聯絡方式的時候會在資料庫內存儲使用者的IDusers.id

透過Python Shell來improt設定的兩個資料類別，並新增使用者，範例如下：






>>> from model_login import User
>>> from model_login import Contact
>>> from model_login import db
>>> admin=User(username='admin',email='admin@abc.com')
>>> admin.contacts
[]

第4行：建立一個新的使用者，使用者名稱為admin
第5行：查詢關聯，回傳為空的list，這是因為我們尚未建置任何關聯資料

現在我們來建立聯絡方式，範例如下：






>>> contact = Contact(contact_style='email',contact_context='admin2@abc.com')
>>> admin.contacts.append(contact)
>>> admin.contacts
[contact_style:email, contact_context:admin2@abc.com]
>>> contact.user
<User 'admin'>

第1行：建立新的聯絡方式
第2行：利用append的方式將該物件寫入list，也就是我們設置的關聯contacts
第3行：查詢目前使用者的聯絡方式
第5行：查詢這聯絡方式的使用者，注意到user即是我們在db.relationship中設置的backref=user

到這邊，應該可以理解相關的設置邏輯，也可能很驚訝就這樣就已經完成了一個表單的關聯，而且是雙向的設置，這代表如果我們要清除資料的話，只需要刪除一邊即可，如下：



>>> contact.user = None
>>> admin.contacts
[]

上面的案例可以看的出來，將contact.user設置為None之後，admin.contacts也變空的list了，非常令人驚豔。

現在我們來看將資料正式的寫入資料庫的情況，如下：





admin=User(username='admin',email='admin@abc.com')
contact = Contact(contact_style='email',contact_context='admin2@abc.com')
admin.contacts.append(contact)
db.session.add(admin)
db.session.commit()

執行之後會發現，雖然session.add只有將admin這個類寫入，但是在關聯設置之下contact也一併寫入資料庫。

另一種關聯寫入資料的方式











>>> from model_login import db,User,Contact
>>> db.create_all()
>>> user_admin = User(username='admin',email='admin@abc.com')
>>> contact_admin = Contact(contact_style='phone',
                            contact_context='3345678', user=user_admin)
>>> user_admin.contacts
[contact_style:phone, contact_context:3345678]
>>> contact_admin.user
<User 'admin'>
>>> db.session.add_all([user_admin, contact_admin])
>>> db.session.commit()

第5行：實作中加入關聯物件

上面範例，在實作『多』的物件時直接利用backref屬性設置關聯之後寫入資料庫。

relationship_lazy

在建立好User跟Contact的關聯之後，我們嚐試著select一筆使用者資料，如下：



>>> user_query = User.query.filter_by(username='admin').first()
>>> user_query.contacts
[contact_style:phone, contact_context:3345678, contact_style:email, contact_context:admin2@abc.com]

透過user_query.contacts查詢會發現相關關聯資料已經幫你一起帶出了，很不錯吧，又一次的驚豔!

只是這種情況下會有一個問題，如果你想再透過查詢式query來查詢你的contacts就沒有辦法了，因為生米已成熟飯，它的type已經是list，我們必需保留它是物件的狀態，在有需要的時候我們再來對關聯資料做二次查詢。

這時候就需要調整db.relationship的參數，加入lazy，調整如下：














class User(db.Model):
    __tablename__ = 'users'
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True, nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)
    #  設置關聯，relationship設置於一對多的『一』
    contacts = db.relationship('Contact', backref='user', lazy='dynamic')

    # def __init__(self, username, email):
    #     self.username = username
    #     self.email = email

    def __repr__(self):
        return '<User %r>' % self.username

第7行：加入參數lazy='dynamic'

透過參數lazy='dynamic'可以讓SQLAlchemy在搜尋關聯資料的時候保留物件狀態，如下說明：

>>> user_query = User.query.filter_by(username='admin').first()
>>> user_query.contacts()
<sqlalchemy.orm.dynamic.AppenderBaseQuery object at 0x0000000003ACFC50>

這時候回傳資料是一個SQLAlchemy物件類別，這樣就可以透過filter的方式再來做二次搜尋，或是透過order_by做排序，如下範例：











#  透過all做全部呈現
>>> user_query.contacts.all()
[contact_style:phone, contact_context:3345678, contact_style:email, contact_context:admin2@abc.com]
#  透過order by做排序
>>> user_query.contacts.order_by(Contact.contact_style).all()
[contact_style:email, contact_context:admin2@abc.com, contact_style:phone, contact_context:3345678]
>>> user_query.contacts.order_by(Contact.id).all()
[contact_style:phone, contact_context:3345678, contact_style:email, contact_context:admin2@abc.com]
#  透過filter做過濾條件
>>> user_query.contacts.filter_by(contact_style='email').all()
[contact_style:email, contact_context:admin2@abc.com]

範例_一對一

兩個Model之間的關聯如果是一對一的話，宣告方式與一對多相同，只需要在主要Model的db.relationship中加入參數uselist=False就可以，相同於一對多，也可以利用backref在主要Model中設置uselist。























class User(db.Model):
    __tablename__ = 'users'
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True, nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)
    #  一對一，設置關聯於主要model
    contacts = db.relationship('Contact', backref=backref('user', uselist=False))

    def __repr__(self):
        return '<User %r>' % self.username


class Contact(db.Model):
    __tablename__ = 'contacts'
    id = db.Column(db.Integer, primary_key=True)
    contact_style = db.Column(db.String)
    contact_context = db.Column(db.String)
    #  於次要model設置foreign key
    user_id = db.Column(db.Integer, db.ForeignKey('users.id'))

    def __repr__(self):
        return 'contact_style:%s, contact_context:%s' % \
               (self.contact_style, self.contact_context)

範例_多對多

多對多關聯使用情境，舉例來說：

一篇文章可以有多個分類，一個分類可以存在於多篇文章中，這是一個tag設置的問題
一個使用者可以有多個聯絡方式，而一個聯絡方式可能對應到多個人

在SQLAlchemy中設置多對多我們並不需要去特別的定義一個Model來做中繼，而是透過Table，設罝MetaData記錄兩個Model的ForeignKey，再於db.relationship加入參數secondary來設置關聯表，因為我們是利用flask-sqlalchemy來操作資料庫，所以設置上可以參考flask-sqlalchemy的範例。

flask-sqlalchemy強烈建議，以真正的資料表來記錄多對多的關聯

相關建置說明如下註解：

































#  設置中繼的關聯表
#  flask-sqlalchemy會自動的在資料庫中產生相對應的table
relations = db.Table('relations',
                     db.Column('user_id', db.Integer, db.ForeignKey('users.id')),
                     db.Column('contact_id', db.Integer, db.ForeignKey('contacts.id'))
                     )


class User(db.Model):
    __tablename__ = 'users'
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True, nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)
    #  利用secondary設置關聯中繼表
    #  lazy的部份可以依需求設置為動態與否
    contacts = db.relationship('Contact', secondary=relations, lazy='subquery', 
                               backref=db.backref('user', lazy=True))

    def __repr__(self):
        return '<User %r>' % self.username


class Contact(db.Model):
    __tablename__ = 'contacts'
    id = db.Column(db.Integer, primary_key=True)
    contact_style = db.Column(db.String)
    contact_context = db.Column(db.String)
    #  不需要設置foreign key
    #  user_id = db.Column(db.Integer, db.ForeignKey('users.id'))

    def __repr__(self):
        return 'contact_style:%s, contact_context:%s' % \
               (self.contact_style, self.contact_context)

在利用Python Shell產生資料庫之後，我們來看一下資料庫的狀態，如下圖：

可以看到，雖然我們沒有利用Model來設置table，但SQLAlchemy會依db.Table的設置來產生中繼表，接著產生資料看看它的存取狀態為何，如下：












#  我們先import設置的model
from app import User
from app import Contact
#  增加一個使用者為admin
user = User(username='admin',email='admin@abc.com')
#  增加一個聯絡人
contact = Contact(contact_style='mobile', contact_context='3345678')
#  將聯絡人寫入使用者
user.contacts.append(contact)
#  將資料寫入
db.session.add(user)
db.session.commit()

首先確認資料庫的記錄狀態，可以發現資料庫的中繼表確實的記錄的雙邊的關聯，如下圖：

現在，手動再新增一個使用者，並且套用相同的聯絡人看看，如下：





user = User(username='Cust', email='Cust@abc.com')
contact = Contact.query.filter_by(id=1).first()
user.contacts.append(contact)
db.session.add(user)
db.session.commit()

資料庫的變化狀況如下：

接著測試搜尋Contact，結果如下，直接取下文字貼上：





>>> contact = Contact.query.filter_by(id=1).first()
>>> contact
contact_style:mobile, contact_context:3345678
>>> contact.user
[<User 'admin'>, <User 'Cust'>]

利用Contact回查user會依我們設置的relation lazy參數來回傳，因為我們設置lazy=True，意義等同於lazy=select，如果我們希望在必要時候再透過filter來取值的話，那就記得使用lazy=dynamic，這時候就會如下方一般的回傳物件：


>>> contact.user
<sqlalchemy.orm.dynamic.AppenderBaseQuery object at 0x030DF790>

最後，測試一下刪除，如果我們將聯絡人刪除，這時候的資料庫狀況為何?


>>> db.session.delete(contact)
>>> db.session.commit()

這時候的中繼表相關資料也被刪除了，如果不想要這樣連動刪除資料的話可以透過參數設置來避免。

sqlalchemy的官方說明，雖然說我們使用的是flask-sqlalchemy，但本質上還是小調整之後可以完成的。

其它

多筆寫入

多筆寫入的情況下可以透過db.session.add_all([...list...])的方式來寫入，如果是大量資料要寫入的話，可以利用bulk，這部份也可以查詢SQLAlchemy官方文件

總結

幾個關聯方式練習下來相信對SQLAlchemy都有了初步的瞭解，這已經足夠我們建置系統使用了，不足的在有需求的時候查詢官方文件相信是會有相對應的答案。

Flask-SQLAlchemy_初探：Flask實作_ext_01_Flask-SQLAlchemy_初探
Flask-SQLAlchemy_Query：Flask實作_ext_18_Flask-SQLAlchemy_Query

延伸閱讀

tag設置並非本篇的主旨，但是tag並非一定要設置為多對多，也可以設置一個字串欄位來保存，這邊提供二篇用於mysql中的設置說明，讓人驚訝的是，在tag愈見增長的時候，多對多的效能反而是較不好的。
設置說明
 效能測試

Flask實作_ext_02_Flask-SQLAlchemy_關聯

tags: flask flask_ext python SQLAlchemy

範例

範例_一對多

另一種關聯寫入資料的方式

relationship_lazy

範例_一對一

範例_多對多

其它

多筆寫入

總結

延伸閱讀

Read more

DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models

Book_論文翻譯

Dify + Whisper Asr Webservice

OUTRAGEOUSLY LARGE NEURAL NETWORKS: THE SPARSELY-GATED MIXTURE-OF-EXPERTS LAYER

tags: `flask` `flask_ext` `python` `SQLAlchemy`