Python ORM 與 NoSQL 資料函式庫應用與儲存函式庫模式

– 7 分鐘閱讀

在 Python 開發中，資料函式庫操作是不可或缺的一環。本文將介紹如何使用 Pony ORM 和 Peewee 這兩個 Python ORM 框架來簡化資料函式庫操作，同時也會探討 NoSQL 資料函式庫的應用以及儲存函式庫模式的實踐。我們將涵蓋資料函式庫連線設定、模型定義、CRUD 操作等基本概念，並深入探討 CQRS 設計模式的應用，以提升程式碼的可維護性和可擴充套件性。此外，我們還會提供實際的程式碼範例，示範如何使用這些技術來建立穩固且高效的資料函式庫存取層。

使用 Pony ORM 的儲存函式庫層

Pony ORM 是一個強大的 ORM 框架，提供了簡單易用的方式來定義資料模型和進行 CRUD（Create、Read、Update、Delete）操作。

安裝資料函式庫驅動程式

首先，我們需要安裝資料函式庫驅動程式。假設我們使用的是 MySQL 資料函式庫，我們可以使用以下命令安裝驅動程式：

pip install mysql-connector-python

建立資料函式庫連線

接下來，我們需要建立資料函式庫連線。我們可以使用以下程式碼建立連線：

import pony.orm

db = pony.orm.Database()
db.bind('mysql', host='localhost', user='username', passwd='password', db='database')

定義模型類別

然後，我們需要定義模型類別。例如，我們可以定義一個 User 類別：

class User(db.Entity):
    id = pony.orm.PrimaryKey(int, auto=True)
    name = pony.orm.Required(str)
    email = pony.orm.Required(str)

實作 CRUD 交易

接下來，我們需要實作 CRUD 交易。例如，我們可以定義一個 UserRepository 類別：

class UserRepository:
    def create(self, name, email):
        user = User(name=name, email=email)
        db.session.add(user)
        db.session.commit()
        return user

    def read(self, id):
        return User.get(id=id)

    def update(self, id, name, email):
        user = User.get(id=id)
        user.name = name
        user.email = email
        db.session.commit()
        return user

    def delete(self, id):
        user = User.get(id=id)
        db.session.delete(user)
        db.session.commit()

執行儲存函式庫交易

最後，我們可以執行儲存函式庫交易。例如，我們可以使用以下程式碼建立一個新使用者：

user_repository = UserRepository()
user = user_repository.create('John Doe', 'john@example.com')
print(user.id)  # 輸出：1

使用 Peewee 建立儲存函式庫

Peewee 是另一個強大的 ORM 框架，提供了簡單易用的方式來定義資料模型和進行 CRUD 操作。

安裝資料函式庫驅動程式

首先，我們需要安裝資料函式庫驅動程式。假設我們使用的是 MySQL 資料函式庫，我們可以使用以下命令安裝驅動程式：

pip install mysql-connector-python

建立資料函式庫連線

接下來，我們需要建立資料函式庫連線。我們可以使用以下程式碼建立連線：

import peewee

db = peewee.MySQLDatabase('database', user='username', password='password', host='localhost')

定義模型類別

然後，我們需要定義模型類別。例如，我們可以定義一個 User 類別：

class User(peewee.Model):
    id = peewee.PrimaryKeyField()
    name = peewee.CharField()
    email = peewee.CharField()

    class Meta:
        database = db

實作 CRUD 交易

接下來，我們需要實作 CRUD 交易。例如，我們可以定義一個 UserRepository 類別：

class UserRepository:
    def create(self, name, email):
        user = User(name=name, email=email)
        user.save()
        return user

    def read(self, id):
        return User.get(User.id == id)

    def update(self, id, name, email):
        user = User.get(User.id == id)
        user.name = name
        user.email = email
        user.save()
        return user

    def delete(self, id):
        user = User.get(User.id == id)
        user.delete_instance()

執行儲存函式庫交易

最後，我們可以執行儲存函式庫交易。例如，我們可以使用以下程式碼建立一個新使用者：

user_repository = UserRepository()
user = user_repository.create('John Doe', 'john@example.com')
print(user.id)  # 輸出：1

這樣，我們就完成了使用 Pony ORM 和 Peewee 建立資料函式庫存取層的過程。這兩個函式庫都提供了簡單易用的方式來定義資料模型和進行 CRUD 操作，讓我們可以更容易地與資料函式庫進行互動。

NoSQL 資料函式庫的應用

在現代軟體開發中，NoSQL 資料函式庫已經成為了一種重要的資料儲存解決方案。與傳統的關係型資料函式庫相比，NoSQL 資料函式庫提供了更高的彈性和可擴充套件性。

建立資料表和領域層

在使用 NoSQL 資料函式庫時，首先需要建立資料表和領域層。領域層是指應用程式的商業邏輯層，負責處理資料的驗證、轉換和儲存。下面的程式碼示範瞭如何建立資料表和領域層：

from pymongo import MongoClient

# 建立 MongoDB 連線
client = MongoClient('mongodb://localhost:27017/')

# 建立資料函式庫和集合
db = client['mydatabase']
collection = db['mycollection']

# 定義領域層
class DomainLayer:
    def __init__(self, collection):
        self.collection = collection

    def create(self, data):
        self.collection.insert_one(data)

    def read(self, query):
        return self.collection.find(query)

    def update(self, query, data):
        self.collection.update_one(query, data)

    def delete(self, query):
        self.collection.delete_one(query)

實作 CRUD 交易

CRUD 交易是指建立、讀取、更新和刪除資料的操作。下面的程式碼示範瞭如何實作 CRUD 交易：

# 建立資料
data = {'name': 'John', 'age': 30}
domain_layer = DomainLayer(collection)
domain_layer.create(data)

# 讀取資料
query = {'name': 'John'}
result = domain_layer.read(query)
print(result)

# 更新資料
query = {'name': 'John'}
data = {'$set': {'age': 31}}
domain_layer.update(query, data)

# 刪除資料
query = {'name': 'John'}
domain_layer.delete(query)

執行 CRUD 交易

執行 CRUD 交易需要使用 NoSQL 資料函式庫的驅動程式。下面的程式碼示範瞭如何執行 CRUD 交易：

from pymongo import MongoClient

# 建立 MongoDB 連線
client = MongoClient('mongodb://localhost:27017/')

# 建立資料函式庫和集合
db = client['mydatabase']
collection = db['mycollection']

# 執行 CRUD 交易
def execute_crud_transaction():
    # 建立資料
    data = {'name': 'John', 'age': 30}
    collection.insert_one(data)

    # 讀取資料
    query = {'name': 'John'}
    result = collection.find(query)
    print(result)

    # 更新資料
    query = {'name': 'John'}
    data = {'$set': {'age': 31}}
    collection.update_one(query, data)

    # 刪除資料
    query = {'name': 'John'}
    collection.delete_one(query)

execute_crud_transaction()

應用 CQRS 設計模式

CQRS 設計模式是指命令查詢責任分離的設計模式。下面的程式碼示範瞭如何應用 CQRS 設計模式：

from pymongo import MongoClient

# 建立 MongoDB 連線
client = MongoClient('mongodb://localhost:27017/')

# 建立資料函式庫和集合
db = client['mydatabase']
collection = db['mycollection']

# 定義命令和查詢介面
class Command:
    def __init__(self, collection):
        self.collection = collection

    def create(self, data):
        self.collection.insert_one(data)

    def update(self, query, data):
        self.collection.update_one(query, data)

    def delete(self, query):
        self.collection.delete_one(query)

class Query:
    def __init__(self, collection):
        self.collection = collection

    def read(self, query):
        return self.collection.find(query)

# 建立命令和查詢物件
command = Command(collection)
query = Query(collection)

# 執行命令和查詢
command.create({'name': 'John', 'age': 30})
result = query.read({'name': 'John'})
print(result)

定義命令和查詢類別

命令和查詢類別是指用於定義命令和查詢的類別。下面的程式碼示範瞭如何定義命令和查詢類別：

from pymongo import MongoClient

# 建立 MongoDB 連線
client = MongoClient('mongodb://localhost:27017/')

# 建立資料函式庫和集合
db = client['mydatabase']
collection = db['mycollection']

# 定義命令類別
class CreateCommand:
    def __init__(self, collection):
        self.collection = collection

    def execute(self, data):
        self.collection.insert_one(data)

class UpdateCommand:
    def __init__(self, collection):
        self.collection = collection

    def execute(self, query, data):
        self.collection.update_one(query, data)

class DeleteCommand:
    def __init__(self, collection):
        self.collection = collection

    def execute(self, query):
        self.collection.delete_one(query)

# 定義查詢類別
class ReadQuery:
    def __init__(self, collection):
        self.collection = collection

    def execute(self, query):
        return self.collection.find(query)

建立命令和查詢處理器

命令和查詢處理器是指用於處理命令和查詢的物件。下面的程式碼示範瞭如何建立命令和查詢處理器：

from pymongo import MongoClient

# 建立 MongoDB 連線
client = MongoClient('mongodb://localhost:27017/')

# 建立資料函式庫和集合
db = client['mydatabase']
collection = db['mycollection']

# 建立命令處理器
class CommandHandler:
    def __init__(self, collection):
        self.collection = collection

    def handle(self, command):
        if isinstance(command, CreateCommand):
            command.execute({'name': 'John', 'age': 30})
        elif isinstance(command, UpdateCommand):
            command.execute({'name': 'John'}, {'$set': {'age': 31}})
        elif isinstance(command, DeleteCommand):
            command.execute({'name': 'John'})

# 建立查詢處理器
class QueryHandler:
    def __init__(self, collection):
        self.collection = collection

    def handle(self, query):
        if isinstance(query, ReadQuery):
            return query.execute({'name': 'John'})

存取處理器

存取處理器是指用於存取命令和查詢處理器的物件。下面的程式碼示範瞭如何存取處理器：

from pymongo import MongoClient

# 建立 MongoDB 連線
client = MongoClient('mongodb://localhost:27017/')

# 建立資料函式庫和集合
db = client['mydatabase']
collection = db['mycollection']

# 建立命令處理器
command_handler = CommandHandler(collection)

# 建立查詢處理器
query_handler = QueryHandler(collection)

# 存取處理器
def access_handler():
    # 建立命令
    create_command = CreateCommand(collection)
    update_command = UpdateCommand(collection)
    delete_command = DeleteCommand(collection)

    # 處理命令
    command_handler.handle(create_command)
    command_handler.handle(update_command)
    command_handler.handle(delete_command)

    # 建立查詢
    read_query = ReadQuery(collection)

    # 處理查詢
    result = query_handler.handle(read_query)
    print(result)

access_handler()

設定資料函式庫環境

在開始使用資料函式庫之前，需要設定資料函式庫環境。這包括選擇合適的資料函式倉管理系統、設定資料函式庫連線等步驟。以下是設定資料函式庫環境的步驟：

選擇資料函式倉管理系統

資料函式倉管理系統是用於管理和儲存資料的軟體。常見的資料函式倉管理系統包括 MySQL、PostgreSQL、MongoDB 等。在這裡，我們選擇使用 MongoDB。

安裝 PyMongo 驅動

PyMongo 是 MongoDB 的 Python 驅動。它提供了 Python 程式與 MongoDB 之間的介面。安裝 PyMongo 驅動可以使用 pip 指令：

pip install pymongo

設定資料函式庫連線

設定資料函式庫連線需要提供資料函式庫的連線字串。連線字串包括資料函式庫的主機、埠、資料函式庫名稱、使用者名稱和密碼等資訊。以下是設定資料函式庫連線的例子：

from pymongo import MongoClient

# 設定資料函式庫連線字串
client = MongoClient("mongodb://localhost:27017/")

# 選擇資料函式庫
db = client["mydatabase"]

建立模型層

模型層是用於定義資料的結構和行為的。它提供了資料的抽象表示，讓開發者可以更容易地存取和操作資料。以下是建立模型層的步驟：

定義模型類別

模型類別是用於定義資料的結構和行為的。它通常繼承自基礎類別別，例如 pymongo.collection.Collection。以下是定義模型類別的例子：

from pymongo import collection

class User(collection.Collection):
    def __init__(self, db):
        super().__init__(db, "users")

    def find_all(self):
        return self.find()

實作儲存函式庫層

儲存函式庫層是用於封裝資料存取和操作的。它提供了統一的介面，讓開發者可以更容易地存取和操作資料。以下是實作儲存函式庫層的步驟：

定義儲存函式庫類別

儲存函式庫類別是用於封裝資料存取和操作的。它通常繼承自基礎類別別，例如 object。以下是定義儲存函式庫類別的例子：

class UserRepository:
    def __init__(self, db):
        self.db = db

    def find_all(self):
        return self.db.users.find()

執行事務

事務是用於封裝一系列的資料操作的。它提供了統一的介面，讓開發者可以更容易地執行一系列的資料操作。以下是執行事務的步驟：

定義事務類別

事務類別是用於封裝一系列的資料操作的。它通常繼承自基礎類別別，例如 object。以下是定義事務類別的例子：

class Transaction:
    def __init__(self, db):
        self.db = db

    def execute(self):
        # 執行一系列的資料操作
        pass

建立非同步 CRUD 事務

非同步 CRUD 事務是用於封裝一系列的資料操作的。它提供了統一的介面，讓開發者可以更容易地執行一系列的資料操作。以下是建立非同步 CRUD 事務的步驟：

定義非同步 CRUD 事務類別

非同步 CRUD 事務類別是用於封裝一系列的資料操作的。它通常繼承自基礎類別別，例如 object。以下是定義非同步 CRUD 事務類別的例子：

import asyncio

class AsyncCRUDTransaction:
    def __init__(self, db):
        self.db = db

    async def execute(self):
        # 執行一系列的資料操作
        pass

從技術架構視角來看，本文介紹了使用 Pony ORM、Peewee 和 NoSQL 資料函式庫構建資料存取層的不同方法，涵蓋了模型定義、儲存函式庫實作以及事務處理等關鍵環節。透過比較分析，可以發現這些 ORM 框架簡化了資料函式庫操作的複雜性，提升了開發效率。然而，ORM 的使用也存在一些限制，例如效能損耗和物件關係對映的複雜性，需要開發者根據實際情況權衡取捨。更進一步，文章探討了 CQRS 模式在 NoSQL 資料函式庫中的應用，展現了其在提升系統可擴充套件性和效能方面的優勢，但也增加了系統的設計複雜度。展望未來，隨著 NoSQL 資料函式庫的普及和微服務架構的興起，CQRS 模式的應用將更加廣泛，資料存取層的設計也將更加註重彈性、可擴充套件性和效能。玄貓認為，開發者應深入理解不同資料存取方案的特性，並根據專案需求選擇合適的技術方案，才能構建高效能且易於維護的應用程式。

玄貓

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。