4種Python基于字段的不使用元類的ORM實(shí)現(xiàn)方法總結(jié)

更新時(shí)間：2023年12月19日 10:46:40 作者：申公豹本豹

在 Python 中,ORM（Object-Relational Mapping）是一種將對象和數(shù)據(jù)庫之間的映射關(guān)系進(jìn)行轉(zhuǎn)換的技術(shù),本文為大家整理了4種不使用元類的簡單ORM實(shí)現(xiàn)方式,需要的可以參考下

在 Python 中，ORM（Object-Relational Mapping）是一種將對象和數(shù)據(jù)庫之間的映射關(guān)系進(jìn)行轉(zhuǎn)換的技術(shù)，使得通過面向?qū)ο蟮姆绞絹聿僮鲾?shù)據(jù)庫更加方便。通常，我們使用元類（metaclass）來實(shí)現(xiàn)ORM，但是本文將介紹一種不使用元類的簡單ORM實(shí)現(xiàn)方式。

Field類

首先，我們定義一個(gè)Field類，用于表示數(shù)據(jù)庫表中的字段。這個(gè)類包含字段的名稱和類型等信息，并且支持一些比較操作，以便后續(xù)構(gòu)建查詢條件。

class Field:
    def __init__(self, **kwargs):
        self.name = kwargs.get('name')
        self.column_type = kwargs.get('column_type')

    def __eq__(self, other):
        return Compare(self, '=', other)

    # 其他比較操作略...

Compare類

為了構(gòu)建查詢條件，我們引入了一個(gè)Compare類，用于表示字段之間的比較關(guān)系。它可以支持鏈?zhǔn)讲僮鳎瑯?gòu)建復(fù)雜的查詢條件。

class Compare:
    def __init__(self, left: Field, operation: str, right: Any):
        self.condition = f'`{left.name}` {operation} "{right}"'

    def __or__(self, other: "Compare"):
        self.condition = f'({self.condition}) OR ({other.condition})'
        return self

    def __and__(self, other: "Compare"):
        self.condition = f'({self.condition}) AND ({other.condition})'
        return self

Model類

接下來，我們定義Model類，表示數(shù)據(jù)庫中的表。該類通過Field類的實(shí)例來定義表的字段，并提供了插入數(shù)據(jù)的方法。

class Model:
    def __init__(self, **kwargs):
        _meta = self.get_class_meta()

        for k, v in kwargs.items():
            if k in _meta:
                self.__dict__[k] = v

    @classmethod
    def get_class_meta(cls) -> Dict:
        if hasattr(cls, '_meta'):
            return cls.__dict__['_meta']
        _meta = {}

        for k, v in cls.__dict__.items():
            if isinstance(v, Field):
                if v.name is None:
                    v.name = k
                name = v.name
                _meta[k] = (name, v)

        table = cls.__dict__.get('__table__')
        table = cls.__name__ if table is None else table
        _meta['__table__'] = table

        setattr(cls, '_meta', _meta)

        return _meta

    def insert(self):
        _meta = self.get_class_meta()
        column_li = []
        val_li = []

        for k, v in self.__dict__.items():
            field_tuple = _meta.get(k)
            if field_tuple:
                column, field = field_tuple
                column_li.append(column)
                val = str(v) if field.column_type == 'INT' else f'"{str(v)}"'
                val_li.append(val)

        sql = f'INSERT INTO {_meta["__table__"]} ({",".join(column_li)}) VALUES ({",".join(val_li)});'
        print(sql)

Query類

最后，我們實(shí)現(xiàn)了Query類，用于構(gòu)建數(shù)據(jù)庫查詢。這個(gè)類支持鏈?zhǔn)秸{(diào)用，可以設(shè)置查詢條件、排序等。

class Query:
    def __init__(self, cls: Model):
        self._model = cls
        self._order_columns = None
        self._desc = ''
        self._meta = self._model.get_class_meta()
        self._compare = None
        self.sql = ''

    def _get(self) -> str:
        sql = ''

        if self._compare:
            sql += f' WHERE {self._compare.condition}'

        if self._order_columns:
            sql += f' ORDER BY {self._order_columns}'

        sql += f' {self._desc}'
        return sql

    def get(self, *args: Field) -> List[Model]:
        sql = self._get()
        table = self._meta['__table__']

        column_li = []

        if len(args) > 0:
            for field in args:
                column_li.append(f'`{field.name}`')
        else:
            for v in self._meta.values():
                if type(v) == tuple and isinstance(v[1], Field):
                    column_li.append(f'`{v[0]}`')

        columns = ",".join(column_li)
        sql = f'SELECT {columns} FROM {table} {sql}'
        self.sql = sql
        print(self.sql)

    def order_by(self, columns: Union[List, str], desc: bool = False) -> "Query":
        if isinstance(columns, str):
            self._order_columns = f'`{columns}`'
        elif isinstance(columns, list):
            self._order_columns = ','.join([f'`{x}`' for x in columns])

        self._desc = 'DESC' if desc else ''
        return self

    def where(self, compare: "Compare") -> "Query":
        self._compare = compare
        return self

示例使用

現(xiàn)在，我們可以定義一個(gè)模型類，并使用這個(gè)簡單的ORM實(shí)現(xiàn)進(jìn)行數(shù)據(jù)操作。

class User(Model):
    name = Field()
    age = Field()

# 插入數(shù)據(jù)
user = User(name='Tom', age=24)
user.insert()

# 構(gòu)建查詢條件并查詢數(shù)據(jù)
User.query().where((User.name == 'Tom') & (User.age >= 20)).order_by('age').get()

這樣，我們就完成了一個(gè)不使用元類的簡單ORM實(shí)現(xiàn)。盡管相較于使用元類的方式，代碼結(jié)構(gòu)更為簡單，但在實(shí)際應(yīng)用中，根據(jù)項(xiàng)目需求和團(tuán)隊(duì)的約定，選擇合適的實(shí)現(xiàn)方式是很重要的。

我們已經(jīng)介紹了一個(gè)基于 Python 的簡單 ORM 實(shí)現(xiàn)，它不依賴于元類。在這一部分，我們將繼續(xù)探討這個(gè)實(shí)現(xiàn)，深入了解查詢構(gòu)建和更復(fù)雜的用法。

擴(kuò)展查詢功能

我們的查詢功能還比較簡單，為了更好地支持復(fù)雜查詢，我們可以添加更多的查詢方法和條件。

支持 LIMIT 和 OFFSET

class Query:
    # ...

    def limit(self, num: int) -> "Query":
        self.sql += f' LIMIT {num}'
        return self

    def offset(self, num: int) -> "Query":
        self.sql += f' OFFSET {num}'
        return self

支持 GROUP BY 和 HAVING

class Query:
    # ...

    def group_by(self, columns: Union[List, str]) -> "Query":
        if isinstance(columns, str):
            columns = [columns]
        self.sql += f' GROUP BY {",".join([f"`{x}`" for x in columns])}'
        return self

    def having(self, condition: Compare) -> "Query":
        self.sql += f' HAVING {condition.condition}'
        return self

示例用法

class User(Model):
    name = Field()
    age = Field()

# 插入數(shù)據(jù)
user = User(name='Tom', age=24)
user.insert()

# 構(gòu)建查詢條件并查詢數(shù)據(jù)
query = User.query().where((User.name == 'Tom') & (User.age >= 20)).order_by('age').limit(1).offset(0)
query.get(User.name, User.age)  # 僅查詢指定字段

# 更復(fù)雜的查詢
query = User.query().group_by('age').having((User.age > 20) & (User.age < 30)).order_by('age').limit(10).offset(0)
query.get(User.age, User.count(User.name))  # 查詢年齡在20到30之間的用戶數(shù)量

通過引入額外的查詢功能，我們使得這個(gè)簡單的 ORM 實(shí)現(xiàn)更加強(qiáng)大和靈活。

總結(jié)

在這個(gè)系列的文章中，我們通過不使用元類的方式，實(shí)現(xiàn)了一個(gè)簡單的 Python ORM。我們定義了 Field 類表示數(shù)據(jù)庫字段，Model 類表示數(shù)據(jù)庫表，以及 Query 類用于構(gòu)建和執(zhí)行查詢。通過這個(gè)實(shí)現(xiàn)，我們可以方便地進(jìn)行數(shù)據(jù)操作，構(gòu)建靈活的查詢條件，而不需要深入理解元類的概念。

然而，這個(gè)簡單的 ORM 仍然有一些局限性，例如不支持復(fù)雜的表關(guān)聯(lián)等功能。在實(shí)際項(xiàng)目中，選擇使用元類的 ORM 實(shí)現(xiàn)或其他成熟的 ORM 框架取決于項(xiàng)目的需求和團(tuán)隊(duì)的技術(shù)選型。希望這個(gè)實(shí)現(xiàn)能夠?yàn)槟闾峁┮环N不同的思路，促使更多的思考和探討。

以上就是4種Python基于字段的不使用元類的ORM實(shí)現(xiàn)方法總結(jié)的詳細(xì)內(nèi)容，更多關(guān)于Python實(shí)現(xiàn)ORM的資料請關(guān)注腳本之家其它相關(guān)文章！

您可能感興趣的文章: