仿优酷系统的orm
仿优酷系统项目orm
首先orm分别是
object relationship mopping
对象关系映射
是将对象映射成数据表中的一条条记录
类 对应 表明
对象 对应 记录
对象.属性 对应 字段
大体的思路：
首先是字段父类型 Field 属性包含 字段名name， 字段类型column_type ， 是否是主键primary_key, 默认值 default
接着：
字符串字段类 StringField
整型字段类型 IntegerField
自定义元类：OrmMetaClass
1.要保证每一张都必须要有表名
2.保证一张表中只能有一个主键
3.将所有的“字段名”与“字段对象”添加到一个独立的字典中（mappings），
再添加到类的名称空间中去， 以key（字段名）：value（字段对象）
基本的步骤：
1.首先过滤models类
2.获取table表名，如果传过来的名称空间中有自定义的表名，就用自定义的，否则默认将类名作为表名
3.保证每一张表只能有一个唯一的主键
- 先给一个空的主键
- 再创建一个空的mappings集合
- 遍历里面的class_attr，过滤。。
- 将所有的字段名与字段对象存进mappings集合中
4.要过滤掉类的名称空间中的重复的字段属性
5.给类的名称空间中，添加table_name, primary_key , mappings
定义父类Models
1.为了在定义每个表对应的类时，不用重复的写 __ init __ 方法，以及不需要确定每张表的字段个数，以及字段的名字，让父类继承dict类
2.用 __ getattr __ 与 __ setattr __,让对象.属性可以取值，对象.属性=属性可以增加或修改属性
示例代码
# 字段的父类
class Field:
def __init__(self, name, column_type, primary_key, default):
self.name = name
self.column_type = column_type
self.primary_key = primary_key
self.default = default
# 字符串字段
class StringField(Field):
def __init__(self, name, column_type='varchar(64)', primary_key=False, default=None):
super().__init__(name, column_type, primary_key, default)
# 整型字段
class IntegerField(Field):
def __init__(self, name, column_type='int', primary_key=False, default=0):
super().__init__(name, column_type, primary_key, default)
# 自定义元类
class OrmMetaClass(type):
def __new__(cls, class_name, class_bases, class_attr):
# 首先过滤掉无用的Models
if class_name == 'Models':
return type.__new__(cls, class_name, class_bases, class_attr)
# 获取table的值，有自定义的用自定义的，没有的话默认用类名来当做表明
table_name = class_attr.get('table_name', class_name)
# 保证每一张表都有唯一的一个主键
primary_key = None
# 创建一个空的集合，用来存放字段名，字段对象
mappings = {}
for k, v in class_attr.items():
if isinstance(v, Field):
if v.primary_key:
if primary_key:
raise TypeError('一个表中只能有一个主键！')
primary_key = k
mappings[k] = v
# 过滤掉重复的字段属性
for i in mappings.keys():
class_attr.pop(i)
#确保表中有主键
if not primary_key:
raise TypeError('一个表中必须要有一个主键！')
# 给类的名称空间中加上表名， 主键和mapping集合
class_attr['table_name'] = table_name
class_attr['primary_key'] = primary_key
class_attr['mappings'] = mappings
# 表的父类
class Models(dict, metaclass=OrmMetaClass):
# 在对象.属性属性不存在时，触发
def __getattr__(self, item):
return self.get(item)
# 在对象.属性=属性值时，触发
def __setattr__(self, key, value):
self[key] = value
# 用户表对应的类
class User(Models):
id = IntegerField(name='id', primary_key=True)
name = StringField(name='name')
age = IntegerField(name='age')
if __name__ == '__main__':
pass
mysql类的代码演示
import pymysql
# mysql类
class MySql:
__instance = None
# 单例模式
@classmethod
def singleton(cls):
if not cls.__instance:
cls.__instance = cls()
return cls.__instance
# mysql类实例化时生成的数据库连接对象
def __init__(self):
self.mysql_client = pymysql.connect(
user='root',
password='555',
host='127.0.0.1',
port=3306,
charset='utf8',
database='yk_demo',
autocommit=True
)
# 生成的游标对象
self.cursor = self.mysql_client.cursor(
pymysql.cursors.DictCursor
)
# 自定义的查询方法
def select(self, sql, args=None):
try:
self.cursor.execute(sql, args)
res1 = self.cursor.fetchall()
return res1
except Exception as e:
return e
# 自定义的提交sql语句的方法
def execute(self, sql, args=None):
try:
self.cursor.execute(sql, args)
except Exception as e:
print(e)
# 关闭游标和数据库连接
def close(self):
# 先关游标
self.cursor.close()
# 再关数据库连接
self.mysql_client.close()
if __name__ == '__main__':
# obj1 = MySql.singleton()
# obj2 = MySql.singleton()
# print(id(obj1))
# print(id(obj2))
obj = MySql.singleton()
# res = obj.select('select *from user')
# print(res)
sql = 'insert into user(name) values(%s)'
obj.execute(sql, 'egon')
