如何自己编写的ORM

最新推荐文章于 2025-06-07 09:01:44 发布
原创 最新推荐文章于 2025-06-07 09:01:44 发布 · 699 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文介绍了如何使用ORM（对象关系映射）技术编写简单的Python类来映射数据库中的表，以实现数据的增删改查操作。通过定义类、字段和元类，实现了基本的表创建和对象操作。

起步：编写简单的ORM对象

写一个类映射某个数据表，下面是写一个User类，对应数据库中的user表：

1
2
3
4
class User(Model):
     
    id = StringField(primary_key=True,ddl='varchar(50)')
    name = StringField(ddl='varchar(50)')

 

这个表中只有两个字段，id和name，为了简便，这两个字段都为StringField类型。其中StringField类型也为定义的类，对应数据库中的varchar类型。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
class Field(object):
    _count = 0
    def __init__(self,**kw):
        self.name = kw.get('name',None)
        self._default = kw.get('default',None)
        self.nullable = kw.get('nullable',False)
        self.primary_key = kw.get('primary_key',False)
        self._order = Field._count
        Field._count = Field._count + 1
        print 'xxx'
        self.ddl = kw.get('ddl','')
 
    @property
    def default(self):
        d = self._default
        return d() if callable(d) else d
    def __str__(self):
        s = ['<%s:%s,%s,default(%s),' % (self.__class__.__name__,self.name,self.ddl,self._default)]
        self.nullable and s.append('N')
        s.append('>')
        return ''.join(s)
class StringField(Field):
    def __init__(self,**kw):
        if not 'default' in kw:
            kw['default'] = ''
        if not 'ddl' in kw:
            kw['ddl'] = 'varchar(250)'
        super(StringField,self).__init__(**kw)

 其中Field为基类，可以将数据库中的类型扩充完。然后在写一个Model类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Model(dict):
    __metaclass__ = ModelMetaclass
 
    def __init__(self,**kw):
        super(Model,self).__init__(**kw)
 
    def __getattr__(self,key):
        try:
            return self[key]
        except KeyError:
            raise AttributeError(r"'Model' object has no attribute '%s'" % key)
 
    def __setattr__(self,key,value):
        self[key] = value
        print '%s: %s' % self,value

 Model类父类为dict，其中__metaclass__为元类。这个是整个代码的基础。元类创建一个ModelMetaclass类的实例，注意__new__(cls,name,bases,attrs)中的四个参数表示的意思就很好理解了：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
class ModelMetaclass(type):
    def __new__(cls,name,bases,attrs):
        if name == 'Model':
            return type.__new__(cls,name,bases,attrs)
        print ('Found model: %s' % name)
        mappings = dict()
        primary_key = None
        li = []
        for k,v in attrs.iteritems():
            if isinstance(v,Field):
                if not v.name:
                    v.name = k
                if v.primary_key:
                    if primary_key:
                        raise TypeError('Cannot define more than one primary key in class: %s' % name)
                    if v.nullable:
                        v.nullable = False
                    primary_key = v
                mappings[k] = v
        if not primary_key:
            raise TypeError('Primary key not defined in class: %s' % name)
        for k in mappings.iterkeys():
            attrs.pop(k)
        attrs['__table__'] = name.lower()
        attrs['__mappings__'] = mappings
        attrs['__primary_key__'] = primary_key
        attrs['__sql__'] =  _gen_sql(attrs['__table__'],mappings)
        print str(attrs['__sql__'])
        tables.append(attrs['__sql__'])
        for trigger in _triggers:
            if not trigger in attrs:
                attrs[trigger] = None
        return type.__new__(cls,name,bases,attrs)

 最后是完整的代码，不过只实现了创建表的功能，这只是万里长征的第一步，慢慢来吧：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# orm.py
tables = []
# Field类
class Field(object):
    _count = 0
    def __init__(self,**kw):
        print 'aaa'
        self.name = kw.get('name',None)
        self._default = kw.get('default',None)
        self.nullable = kw.get('nullable',False)
        self.primary_key = kw.get('primary_key',False)
        self._order = Field._count
        Field._count = Field._count + 1
        print 'xxx'
        self.ddl = kw.get('ddl','')
 
    @property
    def default(self):
        d = self._default
        return d() if callable(d) else d
    def __str__(self):
        s = ['<%s:%s,%s,default(%s),' % (self.__class__.__name__,self.name,self.ddl,self._default)]
        self.nullable and s.append('N')
        s.append('>')
        return ''.join(s)
class StringField(Field):
    def __init__(self,**kw):
        if not 'default' in kw:
            kw['default'] = ''
        if not 'ddl' in kw:
            kw['ddl'] = 'varchar(250)'
        super(StringField,self).__init__(**kw)
_triggers = frozenset(['pre_insert','pre_update','pre_insert'])
# 生成sql语句
def _gen_sql(table_name,mappings):
    pk = None
    sql = ['create table `%s` (' % table_name]
    for f in sorted(mappings.values(),lambda x,y:cmp(x._order, y._order)):
        if not hasattr(f,'ddl'):
            raise StandardError('No ddl in field `%s`' % n)
        ddl = f.ddl
        nullable = f.nullable
        if f.primary_key:
            pk = f.name
        sql.append(nullable and ' `%s` %s' % (f.name,ddl) or ' `%s` %s not null' % (f.name,ddl))
        if pk:
            sql.append(' primary key,')
        pk = None
    sql.append(');')
    return '\n'.join(sql)
         
class ModelMetaclass(type):
    def __new__(cls,name,bases,attrs):
        if name == 'Model':
            return type.__new__(cls,name,bases,attrs)
        print ('Found model: %s' % name)
        mappings = dict()
        primary_key = None
        li = []
        for k,v in attrs.iteritems():
            if isinstance(v,Field):
                if not v.name:
                    v.name = k
                if v.primary_key:
                    if primary_key:
                        raise TypeError('Cannot define more than one primary key in class: %s' % name)
                    if v.nullable:
                        v.nullable = False
                    primary_key = v
                mappings[k] = v
        if not primary_key:
            raise TypeError('Primary key not defined in class: %s' % name)
        for k in mappings.iterkeys():
            attrs.pop(k)
        attrs['__table__'] = name.lower()
        attrs['__mappings__'] = mappings
        attrs['__primary_key__'] = primary_key
        attrs['__sql__'] =  _gen_sql(attrs['__table__'],mappings)
        print str(attrs['__sql__'])
        tables.append(attrs['__sql__'])
        for trigger in _triggers:
            if not trigger in attrs:
                attrs[trigger] = None
        return type.__new__(cls,name,bases,attrs)
 
class Model(dict):
    __metaclass__ = ModelMetaclass
 
    def __init__(self,**kw):
        super(Model,self).__init__(**kw)
 
    def __getattr__(self,key):
        try:
            return self[key]
        except KeyError:
            raise AttributeError(r"'Model' object has no attribute '%s'" % key)
 
    def __setattr__(self,key,value):
        self[key] = value
        print '%s: %s' % self,value
　　# 该方法可以注释掉
    def save(self):
        fields = []
        params = []
        args = []
        for k,v in self.__mappings__.iteritems():
            fields.append(v.name)
            params.append('?')
            args.append(getattr(self,k,None))
        sql = 'insert into %s (%s) values(%s)' % (self.__table__,','.join(fields),','.join(params))
        print sql
        print ('ARGS: %s' % str(args))
 
class User(Model):
     
    id = StringField(primary_key=True,ddl='varchar(50)')
    name = StringField(ddl='varchar(50)')
 
sql = ''.join(tables)
sql = sql.replace('`','')
print sql
import mysql.connector
config = {'user':'root','password':'z5201314','host':'127.0.0.1','port':3306,'database':'test'}
cxn = mysql.connector.connect(**config)
cursor = cxn.cursor()
cursor.execute(sql)

 运行结果：

查看数据库：

sxw3718401
关注
python编写自己的库_Python学习 - 编写自己的ORM（1）
weixin_29378975的博客
12-23 428
这篇博文参考的是廖雪峰的Python教程的实战部分， 传送门 。推荐大家看看装饰器和使用元类这两个章节，然后在看实战部分。这篇博文有时间了还会更新，主要是学习Python的语法，如上面提到的装饰器和元类。起步：编写简单的ORM对象写一个类映射某个数据表，下面是写一个User类，对应数据库中的user表：python">class User(Model):id = StringField(pr...
15、编写ORM
weixin_34233679的博客
07-05 1098
15、编写ORM 概述 在一个Web App中，所有数据，包括用户信息、发布的日志、评论等，都存储在数据库中。 Web App里面有很多地方都要访问数据库。访问数据库需要创建数据库连接、游标对象，然后执行SQL语句，最后处理异常，清理资源。这些访问数据库的代码如果分散到各个函数中，势必无法维护，也不利于代码复用。 所以，我们要首先把常用的...
python中def(参数，参数)函数中return（返回）、及def()..if..else的用法及理解
水亦流人必上的博客
06-09 9062
def add(a,b,c,d): #定义add这个函数、里面有4个参数 e=a+b+c+d #变量E、函数里面的4个参数相加 return e #return返回、返回E变量值 f=add(231,3121,1231,231) #调用函数时、一定要给参数赋值、有多少个参数就赋多少个值、那4个参数相加的值就赋给变量F、.
C#手把手教你写一个自己的ORM（一）
qq_43535970的博客
10-26 2552
网上的ORM框架很多，比如Freesql、sqlsugar、EF等等，在一个新项目中，我们可以直接引入使用；但是有个问题，如果你接手的事一个老项目，实体不能动，代码不能给人家搞乱，那你该怎么办呢？这个时候，我们就需要自己了解一下ORM的原理，然后自己写一个简易的，符合自己公司框架逻辑的ORM进行使用了。下面我会从浅到深，讲解一下ORM的基本实现方法。
手把手教你写ORM（七）
bilahone的博客
01-25 204
恕我卖个关子，如何得到Attribute的问题先放一放，肯定通过反射，有兴趣的也可以自己研究研究今天先来说缓存的问题，对于数据缓存就我自己来说经历过很多次的反复，不过在.NET社区很多人都支持按需读取的原则，不过我觉的这是个误区，在单击程序的时候由于个人电脑的内存比较小和多用途性，很多程序都强调尽量少占用内存。不过在写服务程序的时候就是一个误区了，把常用数据缓存起来，在需要的时候快速调用才是提高性...
python orm框架_Python编写ORM框架
weixin_39718286的博客
12-18 343
ORM全称“Object Relational Mapping”，即对象-关系映射，就是把关系数据库的一行映射为一个对象，也就是一个类对应一个表，这样，写代码更简单，不用直接操作SQL语句。要编写一个ORM框架，所有的类都只能动态定义，因为只有使用者才能根据表的结构定义出对应的类来，使用 metaclass 。编写底层模块的第一步，就是先把调用接口写出来。比如，使用者如果使用这个ORM框架，想定义...
Hibernate ORM 测试用例编写指南
最新发布
gitblog_01039的博客
06-07 461
Hibernate ORM 测试用例编写指南 【免费下载链接】hibernate-orm hibernate-orm/hibernate-orm: 是 Hibernate ORM 的开源项目，用于对象关系映射和数据库操作。该项目包含了各种 ORM 技术和工具，可以方便地实现数据库表和对象之间的映射和操作，提高数据访问效率...
python orm_Python中编写ORM框架的入门指引
weixin_39839726的博客
11-29 249
有了db模块，操作数据库直接写SQL就很方便。但是，我们还缺少ORM。如果有了ORM，就可以用类似这样的语句获取User对象：user = User.get('123')而不是写SQL然后再转换成User对象：u = db.select_one('select * from users where id=?', '123')user = User(**u)所以我们开始编写ORM模块：transwa...
python学习——编写ORM
youzhouliu的博客
07-26 4432
在一个Web App中，所有数据，包括用户信息、发布的日志、评论等，都存储在数据库中。在awesome-python3-webapp中，我们选择MySQL作为数据库。 Web App里面有很多地方都要访问数据库。访问数据库需要创建数据库连接、游标对象，然后执行SQL语句，最后处理异常，清理资源。这些访问数据库的代码如果分散到各个函数中，势必无法维护，也不利于代码复用。 所以，我们要首先
Day3 编写ORM
笨鸟再不努力，没救了
11-15 2333
百度百科 ORM：对象关系映射，用于实现面向对象编程语言里不同类型系统的数据之间的转换。从效果上说，它其实是创建了一个可在编程语言里使用的“虚拟对象数据库”。 这个webapp选用了mysql，由于以后要大量使用SELECT等语句，先要将其封装好，此外，一旦选择异步IO，后面都要选择异步。 创建连接池首先，类似objectC，先要创建一个连接池，以供复用，这个连接池用__pool全局变量储
编写ORM框架
丰伟磊的博客
12-12 601
ORM:Object-Relational Mapping，把关系数据库中的表结构映射到对象上。
简单ORM工具的设计和编写，自己项目中曾经用过的
anzdnbs11538的博客
03-30 226
　　在之前的一个项目中自己编写了一个简单的ORM小工具,这次重新整理和重构了一下代码,之所以说简单是因为该小工具仅仅实现了增删改查的简单功能,不具备数据缓存,延迟加载，关联操作等高级功能。正因为简单所以用起来也不麻烦，代码也不是很复杂，但是在数据层至少可以减少70%以上的代码编写量，可以减少至少50%以上的SQL语句编写量。 　　 设计思想：实体类中的非null属性都会作为SQL语...
Python编写ORM框架
TaoYuan
12-04 3519
ORM全称“Object Relational Mapping”，即对象-关系映射，就是把关系数据库的一行映射为一个对象，也就是一个类对应一个表，这样，写代码更简单，不用直接操作SQL语句。要编写一个ORM框架，所有的类都只能动态定义，因为只有使用者才能根据表的结构定义出对应的类来，使用 metaclass 。编写底层模块的第一步，就是先把调用接口写出来。比如，使用者如果使用这个ORM框架，想定义一
python orm benchmark_python 编写ORM
weixin_39973196的博客
12-16 63
在一个Web App中，所有数据，包括用户信息、发布的日志、评论等，都存储在数据库中。在awesome-python3-webapp中，我们选择MySQL作为数据库。Web App里面有很多地方都要访问数据库。访问数据库需要创建数据库连接、游标对象，然后执行SQL语句，最后处理异常，清理资源。这些访问数据库的代码如果分散到各个函数中，势必无法维护，也不利于代码复用。所以，我们要首先把常用的SELE...
编写一个ORM框架
张昆
04-20 904
ORM全称“Object Relational Mapping”，即对象-关系映射，就是把关系数据库的一行映射为一个对象，也就是一个类对应一个表，这样，写代码更简单，不用直接操作SQL语句。要编写一个ORM框架，所有的类都只能动态定义，因为只有使用者才能根据表的结构定义出对应的类来。编写底层模块的第一步，就是先把调用接口写出来。比如，使用者如果使用这个ORM框架，想定义一个User类来操作对应的数据
编写ORM-解析
nuyi6832的博客
03-27 795
个人笔记：仅做学习记录    ORM-用来建立数据库和python的中间件，是任务逻辑层和数据库层的桥梁，就是用来简化对数据库进行的增删改查操作，将每一个表实例化为一个对象，每个这个对象中都有自己定义的增删改查的方法和各种属性，对这个表结构性操作的时候就只需要调用不同的操作方法就好了，不同的表就是不同的实例化对象。简化了数据库的学习，不需要创建数据库，不需要编写数据库访问层代码，执行数据库操作就是...
Python 编写ORM时的重难点掌握
上善若水
08-10 2254
前言： 最近才狠下心来 准备做一个自己的博客 原先FuckBlog项目由于后端小伙伴加班而搁置，因此 作为团队PM的我自己也要开始做技术方面了，准备自己先写一个博客看看。 备注- ORM全称：object related mapping 对象关系映射 0x00 为什么需要写一个ORM 首先，我觉得数据库操作不封装是很傻比的。原来我写了一个数据库导入工具，全篇导出...
GORM插件编写指南：扩展你的ORM工具箱
一起coding，一起嗨。
09-12 941
GORM插件编写指南：扩展你的ORM工具箱
Django 的 ORM框架、编写模型类Models
**kwargs的博客
01-15 416
Django 的 ORM框架 ORM（Object Relational Mapping）即对象关系映射，它是一种程序技术，它允许你使用类和对象对数据库进行操作,从而避免通过SQL语句操作数据库 ORM框架的作用 建立模型类和表之间的对应关系，允许我们通过面向对象的方式来操作数据库。 根据设计的模型类生成数据库中的表格。 通过简单的配置就可以进行数据库的切换。 ORM 好处: 只需要面向...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值