python如何写一个orm

在Python中编写一个ORM（对象关系映射）工具主要包括以下几个步骤：定义模型类、定义数据库连接、实现基本的CRUD操作、管理数据库模式、处理模型关系。其中，定义模型类是基础，数据库连接的实现是关键。接下来我们将详细描述如何逐步实现这些功能。

一、定义模型类

在ORM中，模型类用于表示数据库中的表。我们需要定义一个基类 Model，其他具体的模型类将继承这个基类。这个基类会包含一些通用的功能，比如保存数据、更新数据等。

class Model:
    def __init__(self, kwargs):
        self.__dict__.update(kwargs)
    def save(self):
        # 实现保存数据的逻辑
        pass
    def update(self, kwargs):
        # 实现更新数据的逻辑
        pass
    def delete(self):
        # 实现删除数据的逻辑
        pass
    @classmethod
    def find(cls, kwargs):
        # 实现查找数据的逻辑
        pass

二、定义数据库连接

我们需要一个类来管理数据库连接。这可以是一个单例类，确保整个应用程序中只有一个数据库连接实例。

import sqlite3
class Database:
    _instance = None
    def __new__(cls, *args, kwargs):
        if not cls._instance:
            cls._instance = super(Database, cls).__new__(cls, *args, kwargs)
        return cls._instance
    def __init__(self, db_name):
        self.connection = sqlite3.connect(db_name)
        self.cursor = self.connection.cursor()
    def execute(self, query, params=None):
        if params is None:
            params = []
        self.cursor.execute(query, params)
        self.connection.commit()
    def fetchall(self):
        return self.cursor.fetchall()
    def fetchone(self):
        return self.cursor.fetchone()

三、实现基本的CRUD操作

在模型类中，我们需要实现基本的CRUD操作。这些操作将使用数据库连接类来执行SQL查询。

class Model:
    def __init__(self, kwargs):
        self.__dict__.update(kwargs)
    def save(self):
        columns = ', '.join(self.__dict__.keys())
        placeholders = ', '.join(['?'] * len(self.__dict__))
        query = f'INSERT INTO {self.__class__.__name__} ({columns}) VALUES ({placeholders})'
        params = list(self.__dict__.values())
        Database().execute(query, params)
    def update(self, kwargs):
        set_clause = ', '.join([f'{key} = ?' for key in kwargs.keys()])
        query = f'UPDATE {self.__class__.__name__} SET {set_clause} WHERE id = ?'
        params = list(kwargs.values()) + [self.id]
        Database().execute(query, params)
    def delete(self):
        query = f'DELETE FROM {self.__class__.__name__} WHERE id = ?'
        params = [self.id]
        Database().execute(query, params)
    @classmethod
    def find(cls, kwargs):
        where_clause = ' AND '.join([f'{key} = ?' for key in kwargs.keys()])
        query = f'SELECT * FROM {cls.__name__} WHERE {where_clause}'
        params = list(kwargs.values())
        Database().execute(query, params)
        rows = Database().fetchall()
        return [cls(row) for row in rows]

四、管理数据库模式

我们需要一个方法来创建和管理数据库表。这个方法可以在模型类中实现。

class Model:
    @classmethod
    def create_table(cls):
        columns = ', '.join([f'{key} {value}' for key, value in cls.__annotations__.items()])
        query = f'CREATE TABLE IF NOT EXISTS {cls.__name__} ({columns})'
        Database().execute(query)

五、处理模型关系

在ORM中，我们经常需要处理模型之间的关系，比如一对多、多对多关系。我们可以在模型类中添加一些方法来处理这些关系。

class ForeignKey:
    def __init__(self, model):
        self.model = model
class Model:
    def __init__(self, kwargs):
        self.__dict__.update(kwargs)
    @classmethod
    def create_table(cls):
        columns = []
        for key, value in cls.__annotations__.items():
            if isinstance(value, ForeignKey):
                columns.append(f'{key}_id INTEGER')
            else:
                columns.append(f'{key} {value}')
        query = f'CREATE TABLE IF NOT EXISTS {cls.__name__} ({", ".join(columns)})'
        Database().execute(query)
    def save(self):
        columns = ', '.join(self.__dict__.keys())
        placeholders = ', '.join(['?'] * len(self.__dict__))
        query = f'INSERT INTO {self.__class__.__name__} ({columns}) VALUES ({placeholders})'
        params = list(self.__dict__.values())
        Database().execute(query, params)
    @classmethod
    def find(cls, kwargs):
        where_clause = ' AND '.join([f'{key} = ?' for key in kwargs.keys()])
        query = f'SELECT * FROM {cls.__name__} WHERE {where_clause}'
        params = list(kwargs.values())
        Database().execute(query, params)
        rows = Database().fetchall()
        return [cls(row) for row in rows]

示例

我们可以定义一些具体的模型类来测试我们的ORM工具。

class User(Model):
    id: int
    name: str
    email: str
class Post(Model):
    id: int
    title: str
    content: str
    user_id: ForeignKey(User)
创建表
User.create_table()
Post.create_table()
插入数据
user = User(name='John Doe', email='john@example.com')
user.save()
post = Post(title='Hello World', content='This is my first post', user_id=user.id)
post.save()
查找数据
users = User.find(name='John Doe')
for user in users:
    print(user.name, user.email)
posts = Post.find(user_id=user.id)
for post in posts:
    print(post.title, post.content)