我的第一个python web开发框架(30)——定制ORM…

2018-08-17 09:48:24来源:博客园 阅读 ()

新老客户大回馈,云服务器低至5折

  几个复杂的ORM方式都已介绍完了,剩下一些常用的删除、获取记录数量、统计合计数、获取最大值、获取最小值等方法我就不一一详细介绍了,直接给出代码大家自行查看。

  1 #!/usr/bin/env python
  2 # coding=utf-8
  3 
  4 from common import db_helper
  5 
  6 
  7 class LogicBase():
  8     """逻辑层基础类"""
  9 
 10     def __init__(self, db, is_output_sql, table_name, column_name_list='*', pk_name='id'):
 11         """类初始化"""
 12         # 数据库参数
 13         self.__db = db
 14         # 是否输出执行的Sql语句到日志中
 15         self.__is_output_sql = is_output_sql
 16         # 表名称
 17         self.__table_name = str(table_name).lower()
 18         # 查询的列字段名称,*表示查询全部字段,多于1个字段时用逗号进行分隔,除了字段名外,也可以是表达式
 19         self.__column_name_list = str(column_name_list).lower()
 20         # 主健名称
 21         self.__pk_name = str(pk_name).lower()
 22 
 23     #####################################################################
 24     ### 执行Sql ###
 25 
 26     def select(self, sql):
 27         """执行sql查询语句(select)"""
 28         with db_helper.PgHelper(self.__db, self.__is_output_sql) as db:
 29             # 执行sql语句
 30             result = db.execute(sql)
 31             if not result:
 32                 result = []
 33         return result
 34 
 35     def execute(self, sql):
 36         """执行sql语句,并提交事务"""
 37         with db_helper.PgHelper(self.__db, self.__is_output_sql) as db:
 38             # 执行sql语句
 39             result = db.execute(sql)
 40             if result:
 41                 db.commit()
 42             else:
 43                 result = []
 44         return result
 45 
 46     def copy(self, values, columns):
 47         """批量更新数据"""
 48         with db_helper.PgHelper(self.__db, self.__is_output_sql) as db:
 49             # 执行sql语句
 50             result = db.copy(values, self.__table_name, columns)
 51         return result
 52 
 53     def get_model(self, wheres):
 54         """通过条件获取一条记录"""
 55         # 如果有条件,则自动添加where
 56         if wheres:
 57             wheres = ' where ' + wheres
 58 
 59         # 合成sql语句
 60         sql = "select %(column_name_list)s from %(table_name)s %(wheres)s" % \
 61               {'column_name_list': self.__column_name_list, 'table_name': self.__table_name, 'wheres': wheres}
 62         # 初化化数据库链接
 63         result = self.select(sql)
 64         if result:
 65             return result[0]
 66         return {}
 67 
 68     def get_model_for_pk(self, pk, wheres=''):
 69         """通过主键值获取数据库记录实体"""
 70         if not pk:
 71             return {}
 72         # 组装查询条件
 73         wheres = '%s = %s' % (self.__pk_name, str(pk))
 74 
 75         return self.get_model(wheres)
 76 
 77     def get_value(self, column_name, wheres=''):
 78         """
 79         获取指定条件的字段值————多于条记录时,只取第一条记录
 80         :param column_name: 单个字段名,如:id
 81         :param wheres: 查询条件
 82         :return: 7 (指定的字段值)
 83         """
 84         if not column_name:
 85             return None
 86         elif wheres:
 87             wheres = ' where ' + wheres
 88 
 89         sql = 'select %(column_name)s from %(table_name)s %(wheres)s limit 1' % \
 90               {'column_name': column_name, 'table_name': self.__table_name, 'wheres': wheres}
 91         result = self.select(sql)
 92         # 如果查询成功,则直接返回记录字典
 93         if result:
 94             return result[0].get(column_name)
 95 
 96     def get_value_list(self, column_name, wheres=''):
 97         """
 98         获取指定条件记录的字段值列表
 99         :param column_name: 单个字段名,如:id
100         :param wheres: 查询条件
101         :return: [1,3,4,6,7]
102         """
103         if not column_name:
104             column_name = self.__pk_name
105         elif wheres:
106             wheres = ' where ' + wheres
107 
108         sql = 'select array_agg(%(column_name)s) as list from %(table_name)s %(wheres)s' % \
109               {'column_name': column_name, 'table_name': self.__table_name, 'wheres': wheres}
110         result = self.select(sql)
111         # 如果查询失败或不存在指定条件记录,则直接返回初始值
112         if result and isinstance(result, list):
113             return result[0].get('list')
114         else:
115             return []
116 
117     def add_model(self, fields, returning=''):
118         """新增数据库记录"""
119         ### 拼接sql语句 ###
120         # 初始化变量
121         key_list = []
122         value_list = []
123         # 将传入的字典参数进行处理,把字段名生成sql插入字段名数组和字典替换数组
124         # PS:字符串使用字典替换参数时,格式是%(name)s,这里会生成对应的字串
125         # 比如:
126         #   传入的字典为: {'id': 1, 'name': '名称'}
127         #   那么生成的key_list为:'id','name'
128         #   而value_list为:'%(id)s,%(name)s'
129         #   最终而value_list为字符串对应名称位置会被替换成相应的值
130         for key in fields.keys():
131             key_list.append(key)
132             value_list.append('%(' + key + ')s')
133         # 设置sql拼接字典,并将数组(lit)使用join方式进行拼接,生成用逗号分隔的字符串
134         parameter = {
135             'table_name': self.__table_name,
136             'pk_name': self.__pk_name,
137             'key_list': ','.join(key_list),
138             'value_list': ','.join(value_list)
139         }
140         # 如果有指定返回参数,则添加
141         if returning:
142             parameter['returning'] = ', ' + returning
143         else:
144             parameter['returning'] = ''
145 
146         # 生成可以使用字典替换的字符串
147         sql = "insert into %(table_name)s (%(key_list)s) values (%(value_list)s) returning %(pk_name)s %(returning)s" % parameter
148         # 将生成好的字符串替字典参数值,生成最终可执行的sql语句
149         sql = sql % fields
150 
151         result = self.execute(sql)
152         if result:
153             return result[0]
154         return {}
155 
156     def edit(self, fields, wheres='', returning=''):
157         """批量编辑数据库记录"""
158         ### 拼接sql语句 ###
159         # 拼接字段与值
160         field_list = [key + ' = %(' + key + ')s' for key in fields.keys()]
161         # 设置sql拼接字典
162         parameter = {
163             'table_name': self.__table_name,
164             'pk_name': self.__pk_name,
165             'field_list': ','.join(field_list)
166         }
167         # 如果存在更新条件,则将条件添加到sql拼接更换字典中
168         if wheres:
169             parameter['wheres'] = ' where ' + wheres
170         else:
171             parameter['wheres'] = ''
172 
173         # 如果有指定返回参数,则添加
174         if returning:
175             parameter['returning'] = ', ' + returning
176         else:
177             parameter['returning'] = ''
178 
179         # 生成sql语句
180         sql = "update %(table_name)s set %(field_list)s %(wheres)s returning %(pk_name)s %(returning)s" % parameter
181         sql = sql % fields
182 
183         return self.execute(sql)
184 
185     def edit_model(self, pk, fields, wheres='', returning=''):
186         """编辑单条数据库记录"""
187         if not pk:
188             return {}
189         elif wheres:
190             wheres = self.__pk_name + ' = ' + str(pk) + ' and ' + wheres
191         else:
192             wheres = self.__pk_name + ' = ' + str(pk)
193 
194         return self.edit(fields, wheres, returning)
195 
196     def delete(self, wheres='', returning='', is_update_cache=True):
197         """批量删除数据库记录"""
198         # 如果存在条件
199         if wheres:
200             wheres = ' where ' + wheres
201 
202         # 如果有指定返回参数,则添加
203         if returning:
204             returning = ', ' + returning
205 
206         # 生成sql语句
207         sql = "delete from %(table_name)s %(wheres)s returning %(pk_name)s %(returning)s" % \
208               {'table_name': self.__table_name, 'wheres': wheres, 'pk_name': self.__pk_name, 'returning': returning}
209         return self.execute(sql)
210 
211     def delete_model(self, pk, wheres='', returning='', is_update_cache=True):
212         """删除单条数据库记录"""
213         if not pk:
214             return {}
215         elif wheres:
216             wheres = self.__pk_name + ' = ' + str(pk) + ' and ' + wheres
217         else:
218             wheres = self.__pk_name + ' = ' + str(pk)
219 
220         return self.delete(wheres, returning)
221 
222     def get_list(self, column_name_list='', wheres='', page_number=None, page_size=None, orderby=None, table_name=None):
223         """
224         获取指定条件的数据库记录集
225         :param column_name_list:      查询字段
226         :param wheres:      查询条件
227         :param page_number:   分页索引值
228         :param page_size:    分页大小, 存在值时才会执行分页
229         :param orderby:     排序规则
230         :param table_name:     查询数据表,多表查询时需要设置
231         :return: 返回记录集总数量与分页记录集
232             {'records': 0, 'total': 0, 'page': 0, 'rows': []}
233         """
234         # 初始化输出参数:总记录数量与列表集
235         data = {
236             'records': 0,  # 总记录数
237             'total': 0,  # 总页数
238             'page': 1,  # 当前页面索引
239             'rows': [],  # 查询结果(记录列表)
240         }
241         # 初始化查询数据表名称
242         if not table_name:
243             table_name = self.__table_name
244         # 初始化查询字段名
245         if not column_name_list:
246             column_name_list = self.__column_name_list
247         # 初始化查询条件
248         if wheres:
249             # 如果是字符串,表示该查询条件已组装好了,直接可以使用
250             if isinstance(wheres, str):
251                 wheres = 'where ' + wheres
252             # 如果是list,则表示查询条件有多个,可以使用join将它们用and方式组合起来使用
253             elif isinstance(wheres, list):
254                 wheres = 'where ' + ' and '.join(wheres)
255         # 初始化排序
256         if not orderby:
257             orderby = self.__pk_name + ' desc'
258         # 初始化分页查询的记录区间
259         paging = ''
260 
261         with db_helper.PgHelper(self.__db, self.__is_output_sql) as db:
262             #############################################################
263             # 判断是否需要进行分页
264             if not page_size is None:
265                 ### 执行sql,获取指定条件的记录总数量
266                 sql = 'select count(1) as records from %(table_name)s %(wheres)s ' % \
267                       {'table_name': table_name, 'wheres': wheres}
268                 result = db.execute(sql)
269                 # 如果查询失败或不存在指定条件记录,则直接返回初始值
270                 if not result or result[0]['records'] == 0:
271                     return data
272 
273                 # 设置记录总数量
274                 data['records'] = result[0].get('records')
275 
276                 #########################################################
277                 ### 设置分页索引与页面大小 ###
278                 if page_size <= 0:
279                     page_size = 10
280                 # 计算总分页数量:通过总记录数除于每页显示数量来计算总分页数量
281                 if data['records'] % page_size == 0:
282                     page_total = data['records'] // page_size
283                 else:
284                     page_total = data['records'] // page_size + 1
285                 # 判断页码是否超出限制,超出限制查询时会出现异常,所以将页面索引设置为最后一页
286                 if page_number < 1 or page_number > page_total:
287                     page_number = page_total
288                 # 记录总页面数量
289                 data['total'] = page_total
290                 # 记录当前页面值
291                 data['page'] = page_number
292                 # 计算当前页面要显示的记录起始位置(limit指定的位置)
293                 record_number = (page_number - 1) * page_size
294                 # 设置查询分页条件
295                 paging = ' limit ' + str(page_size) + ' offset ' + str(record_number)
296             #############################################################
297 
298             ### 按条件查询数据库记录
299             sql = "select %(column_name_list)s from %(table_name)s %(wheres)s order by %(orderby)s %(paging)s" % \
300                   {'column_name_list': column_name_list,
301                    'table_name': table_name,
302                    'wheres': wheres,
303                    'orderby': orderby,
304                    'paging': paging}
305             result = db.execute(sql)
306             if result:
307                 data['rows'] = result
308                 # 不需要分页查询时,直接在这里设置总记录数
309                 if page_size is None:
310                     data['records'] = len(result)
311 
312         return data
313 
314     def get_count(self, wheres=''):
315         """获取指定条件记录数量"""
316         if wheres:
317             wheres = ' where ' + wheres
318         sql = 'select count(1) as total from %(table_name)s %(wheres)s ' % \
319               {'table_name': self.__table_name, 'wheres': wheres}
320         result = self.select(sql)
321         # 如果查询存在记录,则返回true
322         if result:
323             return result[0].get('total')
324         return 0
325 
326     def get_sum(self, fields, wheres):
327         """获取指定条件记录数量"""
328         sql = 'select sum(%(fields)s) as total from %(table_name)s where %(wheres)s ' % \
329               {'table_name': self.__table_name, 'wheres': wheres, 'fields': fields}
330         result = self.select(sql)
331         # 如果查询存在记录,则返回true
332         if result and result[0].get('total'):
333             return result[0].get('total')
334         return 0
335 
336     def get_min(self, fields, wheres):
337         """获取该列记录最小值"""
338         sql = 'select min(%(fields)s) as min from %(table_name)s where %(wheres)s ' % \
339               {'table_name': self.__table_name, 'wheres': wheres, 'fields': fields}
340         result = self.select(sql)
341         # 如果查询存在记录,则返回true
342         if result and result[0].get('min'):
343             return result[0].get('min')
344 
345     def get_max(self, fields, wheres):
346         """获取该列记录最大值"""
347         sql = 'select max(%(fields)s) as max from %(table_name)s where %(wheres)s ' % \
348               {'table_name': self.__table_name, 'wheres': wheres, 'fields': fields}
349         result = self.select(sql)
350         # 如果查询存在记录,则返回true
351         if result and result[0].get('max'):
352             return result[0].get('max')
353 
354             #####################################################################
View Code

 

  大家只要掌握了ORM简单的组合sql方法,就可以自由发挥,根据自己的需要去创建不同的方法了,也可以随意更换mysql、mssql等数据库。

  当然,这只是最简单的ORM方式,提交字段参数和条件参数时,它不会自动分辨字段的类型,不会自动初始化默认值,如果想让它变的更加强大,还需要做更多的改造与处理,这样做的话它也会跟着变的更加复杂和难懂,性能也会跟着下降。不过当前功能对于多数项目来说,已经足够使用了。大家如果有需要可以自行研究进行扩展。

 

  在日常操作中,获取指定记录实体是最常见使用最频繁的操作,为了减少对数据库的查询,我们可以将ORM与Nosql结合起来,提升ORM的操作性能,当然如果你不想使用nosql缓存,也可以直接跳过本章节。

  使用Nosql,首先我们需要一个链接Nosql的配置文件,用它来存储Nosql的服务地址、端口、密码等参数

  在config文件夹中我们创建redis_config.py配置文件

#!/usr/bin/env python
# coding=utf-8

### redis缓存配置参数 ###
REDIS = {
    # 服务地址
    'server': '127.0.0.1',
    # 服务端口
    'post': 6379,
    # 服务密码
    'pwd': '',
    # 数据库序号
    'db': 1
}

  然后我们还需要一个nosql链接工具包(cache_helper.py),用来对nosql进行set、get、delete和clear操作(存储、获取、删除和清空缓存)

  1 #!/usr/bin/env python
  2 # coding=utf-8
  3 
  4 import redis
  5 
  6 from common import log_helper
  7 from config import redis_config
  8 
  9 # 设置redis配置参数
 10 _redis = redis_config.REDIS
 11 # 初始化Redis缓存链接
 12 r = None
 13 try:
 14     if not r:
 15         r = redis.Redis(host=_redis.get('server', ''),
 16                         port=_redis.get('post', ''),
 17                         db=_redis.get('db', ''),
 18                         password=_redis.get('pwd', ''),
 19                         socket_timeout=1,
 20                         socket_connect_timeout=1)
 21 except Exception as e:
 22     log_helper.info('连接redis出错:(' + str(_redis) + ')' + str(e.args))
 23     pass
 24 
 25 
 26 def set(key, value, time=86400):
 27     """
 28     写缓存
 29     :param key: 缓存key,字符串,不区分大小写
 30     :param value: 要存储的值
 31     :param time: 缓存过期时间(单位:秒),0=永不过期
 32     :return:
 33     """
 34     # 将key转换为小写字母
 35     key = str(key).lower()
 36     try:
 37         r.set(key, value, time)
 38     except Exception as e:
 39         log_helper.info('写缓存失败:key(' + key + ')' + str(e.args))
 40         pass
 41 
 42 
 43 def get(key):
 44     """
 45     读缓存
 46     :param key: 缓存key,字符串,不区分大小写
 47     :return:
 48     """
 49     # 将key转换为小写字母
 50     key = str(key).lower()
 51     try:
 52         value = r.get(key)
 53     except Exception as e:
 54         # log_helper.error('读缓存失败:key(' + key + ')' + str(e.args) + ' r:' + str(r) + ' _redis:' + str(_redis))
 55         value = None
 56 
 57     return _str_to_json(value)
 58 
 59 
 60 def push(key, value):
 61     """
 62     添加数据到队列头部
 63     :param key: 缓存key,字符串,不区分大小写
 64     :param value: 要存储的值
 65     """
 66     # 将key转换为小写字母
 67     key = str(key).lower()
 68     try:
 69         r.lpush(key, value)
 70     except Exception as e:
 71         log_helper.info('写缓存失败:key(' + key + ')' + str(e.args))
 72         pass
 73 
 74 
 75 def pop(key):
 76     """
 77     从缓存队列的后尾读取一条数据
 78     :param key: 缓存key,字符串,不区分大小写
 79     :return: 缓存数据
 80     """
 81     # 将key转换为小写字母
 82     key = str(key).lower()
 83     try:
 84         value = r.rpop(key)
 85     except Exception as e:
 86         log_helper.info('读取缓存队列失败:key(' + key + ')' + str(e.args))
 87         value = None
 88 
 89     return _str_to_json(value)
 90 
 91 
 92 def _str_to_json(value):
 93     """
 94     将缓存中读取出来的字符串转换成对应的数据、元组、列表或字典
 95     """
 96     if not value:
 97         return value
 98     # 否则直接转换
 99     try:
100         value = value.decode()
101         return eval(value)
102     except Exception as e:
103         print(e.args)
104         pass
105     # 否则直接输出字符串
106     return value
107 
108 
109 def delete(key):
110     """
111     删除缓存
112     :param key:缓存key,字符串,不区分大小写
113     :return:
114     """
115     # 将key转换为小写字母
116     key = str(key).lower()
117     try:
118         log_helper.info(str(r.delete(key)))
119     except Exception as e:
120         log_helper.info('Exception:' + str(e.args))
121         pass
122 
123 
124 def clear():
125     """
126     清空所有缓存
127     """
128     try:
129         r.flushdb()
130     except:
131         pass
View Code

  我常用的是redis,所以使用cache_helper.py时,需要安装redis服务和对应的Python包。如果你使用的是memcache,你只需要重构一下cache_helper.py代码就可以了。

  接下来我们改造一下逻辑层基类(ORM模块)

  首先我们需要导入cache_helper

from common import db_helper, cache_helper

  在使用nosql缓存时,大家都知道我们是使用key来进行对象存取的,而这个key也是唯一的,所以key的生成就很重要的,为了避免key的重复,我们在对记录设置key时,可以用表名+主键id的方式来组合key,当然为了调用方便,可以将获取key写成一个方法来生成

    def get_cache_key(self, pk):
        """获取缓存key值"""
        return ''.join((self.__table_name, '_', str(pk)))

  这里使用join的方法,将表名、下横线、主键值组合生成缓存key字符串

 

  对于缓存的操作,主要有设置缓存、获取缓存、删除缓存这三种操作,当然为了方便我们获取记录中指定字段值,我们可以增加读取指定字段值方法。

  首先是设置缓存方法,大家看看下面代码,它非常简单,先调用生成缓存key,然后将对象存储到缓存中,并指定过期时间,当设置time为0时,它将永不过期

    def set_model_for_cache(self, pk, value, time=43200):
        """更新存储在缓存中的数据库记录,缓存过期时间为12小时"""
        # 生成缓存key
        key = self.get_cache_key(pk)
        # 存储到nosql缓存中
        cache_helper.set(key, value, time)

 

  接着是获取缓存对象方法

    def get_model_for_cache(self, pk):
        """从缓存中读取数据库记录"""
        # 生成缓存key
        key = self.get_cache_key(pk)
        # 从缓存中读取数据库记录
        result = cache_helper.get(key)
        # 缓存中不存在记录,则从数据库获取
        if not result:
            result = self.get_model_for_pk(pk)
            self.set_model_for_cache(pk, result)
        if result:
            return result
        else:
            return {}

  我们首先要做的同样是生成缓存key,然后调用get方法从缓存中读取对象,执行完后,需要判断该对象是否存在缓存中,如果不存在则表示该对象并未存储到缓存中或它可能存储过期了,所以需要重新从数据库中读取出来,并将它存储到缓存中,然后将读取出来的记录实体返回出去。

 

  然后我们再增加一个读取指定记录字段值的方法

    def get_value_for_cache(self, pk, column_name):
        """获取指定记录的字段值"""
        return self.get_model_for_cache(pk).get(column_name)

  它直接调用获取缓存对象方法,然后从返回的对象中读取指定的字段值就可以了

 

  删除缓存方法也很简单,生成缓存key后,直接调用delete进行删除。对于删除方法,有时候调用不知是不是nosql自身bug问题,还是在主从关系的nosql中读写分离会引起删除失败,如果出现这种情况,可以将delete改为set,将该缓存set为空就可以解决这个问题

    def del_model_for_cache(self, pk):
        """删除缓存中指定数据"""
        # 生成缓存key
        key = self.get_cache_key(pk)
        # log_helper.info(key)
        # 存储到nosql缓存中
        cache_helper.delete(key)

  PS:在使用缓存操作时,有时我们直接对数据库进行操作,就会引起数据与缓存不匹配,出现脏数据的情况,这时在后台增加清空缓存的操作,直接调用cache_helper.clear()进行清空缓存。

 

  基本方法都完成了,接下来就是要对ORM的删除与修改方法进行改造了,让它们自行根据需要对缓存进行对应操作,让缓存与数据表中的记录保持一致。

  在改造时,我们只需要对删除与修改操作进行处理,对新增与查询操作不需要操作,因为新增的记录,它并在缓存中并不存在,所以不需要进行操作,而查询也不会改变数据内容,只有进行删除和修改操作时,才会变动数据内容,这时就需要更改缓存,让数据保持一致。

  改造编辑记录实体方法

 1     def edit(self, fields, wheres='', returning='', is_update_cache=True):
 2         """
 3         批量编辑数据库记录
 4         :param fields: 要更新的字段(字段名与值存储在字典中)
 5         :param wheres: 更新条件
 6         :param returning: 更新成功后,返回的字段名
 7         :param is_update_cache: 是否同步更新缓存
 8         :return:
 9         """
10         ### 拼接sql语句 ###
11         # 拼接字段与值
12         field_list = [key + ' = %(' + key + ')s' for key in fields.keys()]
13         # 设置sql拼接字典
14         parameter = {
15             'table_name': self.__table_name,
16             'pk_name': self.__pk_name,
17             'field_list': ','.join(field_list)
18         }
19         # 如果存在更新条件,则将条件添加到sql拼接更换字典中
20         if wheres:
21             parameter['wheres'] = ' where ' + wheres
22         else:
23             parameter['wheres'] = ''
24 
25         # 如果有指定返回参数,则添加
26         if returning:
27             parameter['returning'] = ', ' + returning
28         else:
29             parameter['returning'] = ''
30 
31         # 生成sql语句
32         sql = "update %(table_name)s set %(field_list)s %(wheres)s returning %(pk_name)s %(returning)s" % parameter
33         sql = sql % fields
34 
35         result = self.execute(sql)
36         if result:
37             # 判断是否删除对应的缓存
38             if is_update_cache:
39                 # 循环删除更新成功的所有记录对应的缓存
40                 for model in result:
41                     self.del_model_for_cache(model.get('id', 0))
42         return result

  大家可以看到,该方法增加了is_update_cache 是否同步更新缓存参数,这是因为我们在使用缓存时会存在一些特殊情况,比如说批量更新很多数据时,如果使用循环逐条清理对应缓存时,会占用较多资源,我们可以关掉缓存的同步更新,直接调用clear清空所有缓存会更加快捷;又比如说,页面访问数的更新,它会更新的非常频繁,我们不需要实时清除,可以使用其他方式触发清理,也可以将点击数用独立缓存存储使用等

  而清理缓存,我们只需要将缓存内容直接删除就可以了,因为执行更新以后,返回的记录实体没有设置为*时,只返回主键id,直接设置的话会造成缓存数据丢失细节的问题,另外,我们执行更新以后,该记录也不一定还会被读取出来。

 

  删除记录也进行一样的改造

 1     def delete(self, wheres='', returning='', is_update_cache=True):
 2         """
 3         批量删除数据库记录
 4         :param wheres: 删除条件
 5         :param returning: 删除成功后,返回的字段名
 6         :param is_update_cache: 是否同步更新缓存
 7         :return:
 8         """
 9         # 如果存在条件
10         if wheres:
11             wheres = ' where ' + wheres
12 
13         # 如果有指定返回参数,则添加
14         if returning:
15             returning = ', ' + returning
16 
17         # 生成sql语句
18         sql = "delete from %(table_name)s %(wheres)s returning %(pk_name)s %(returning)s" % \
19               {'table_name': self.__table_name, 'wheres': wheres, 'pk_name': self.__pk_name, 'returning': returning}
20         result = self.execute(sql)
21         if result:
22             # 同步删除对应的缓存
23             if is_update_cache:
24                 for model in result:
25                     self.del_model_for_cache(model.get('id', 0))
26         return result

 

  对于缓存基本上就这两个要进行改造的操作了。在实现开发中,我们认真想一想,其实我们还会存在一些特殊的情况,比如说我们对数据进行加工处理后,将加工后的值存储到缓存中,而对相关记录进行修改或删除操作以后,由于这些缓存它与记录并没有关联,所以执行相关操作以后,它就变成孤岛,不会实时同步,产生脏数据。所以我们需要有一个功能,可以将它们管理起来,与该数据表的修改和删除操作关联起来,进行修改和删除操作后同步清除这些特殊缓存。

  根据这些要求,我们就需要再增加两个缓存操作方法,用来存储这些特殊的缓存名称,然后在进行修改和删除操作时,同步清除这些特殊缓存。

  首先我们需要在初始化方法中,添加一个绑定该数据表的全局缓存变量self.__cache_list,它由表名称+_cache_list组成。

 1     def __init__(self, db, is_output_sql, table_name, column_name_list='*', pk_name='id'):
 2         """类初始化"""
 3         # 数据库参数
 4         self.__db = db
 5         # 是否输出执行的Sql语句到日志中
 6         self.__is_output_sql = is_output_sql
 7         # 表名称
 8         self.__table_name = str(table_name).lower()
 9         # 查询的列字段名称,*表示查询全部字段,多于1个字段时用逗号进行分隔,除了字段名外,也可以是表达式
10         self.__column_name_list = str(column_name_list).lower()
11         # 主健名称
12         self.__pk_name = str(pk_name).lower()
13         # 缓存列表
14         self.__cache_list = self.__table_name + '_cache_list'

 

  然后我们再添加特殊缓存存储方法

 1     def add_relevance_cache_in_list(self, key):
 2         """将缓存名称存储到列表里————主要存储与记录变更关联的"""
 3         # 从nosql中读取全局缓存列表
 4         cache_list = cache_helper.get(self.__cache_list)
 5         # 判断缓存列表是否有值,有则进行添加操作
 6         if cache_list:
 7             # 判断是否已存储列表中,不存在则执行添加操作
 8             if not key in cache_list:
 9                 cache_list.append(key)
10                 cache_helper.set(self.__cache_list, cache_list)
11         # 无则直接创建全局缓存列表,并存储到nosql中
12         else:
13             cache_list = [key]
14             cache_helper.set(self.__cache_list, cache_list)

  执行该方法,会将我们自定义的缓存名称存储到全局缓存变量中

 

  接着我们再添加一个清除所有特殊缓存的方法

 1     def del_relevance_cache(self):
 2         """删除关联缓存————将和数据表记录关联的,个性化缓存全部删除"""
 3         # 从nosql中读取全局缓存列表
 4         cache_list = cache_helper.get(self.__cache_list)
 5         # 清除已删除缓存列表
 6         cache_helper.delete(self.__cache_list)
 7         if cache_list:
 8             # 执行删除操作
 9             for cache in cache_list:
10                 cache_helper.delete(cache)

 

  添加完成以后,我们再来改造一下修改与删除代码,只需要在里面添加清除所有特殊缓存方法就可以了

 1     def edit(self, fields, wheres='', returning='', is_update_cache=True):
 2         """
 3         批量编辑数据库记录
 4         :param fields: 要更新的字段(字段名与值存储在字典中)
 5         :param wheres: 更新条件
 6         :param returning: 更新成功后,返回的字段名
 7         :param is_update_cache: 是否同步更新缓存
 8         :return:
 9         """
10         ### 拼接sql语句 ###
11         # 拼接字段与值
12         field_list = [key + ' = %(' + key + ')s' for key in fields.keys()]
13         # 设置sql拼接字典
14         parameter = {
15             'table_name': self.__table_name,
16             'pk_name': self.__pk_name,
17             'field_list': ','.join(field_list)
18         }
19         # 如果存在更新条件,则将条件添加到sql拼接更换字典中
20         if wheres:
21             parameter['wheres'] = ' where ' + wheres
22         else:
23             parameter['wheres'] = ''
24 
25         # 如果有指定返回参数,则添加
26         if returning:
27             parameter['returning'] = ', ' + returning
28         else:
29             parameter['returning'] = ''
30 
31         # 生成sql语句
32         sql = "update %(table_name)s set %(field_list)s %(wheres)s returning %(pk_name)s %(returning)s" % parameter
33         sql = sql % fields
34 
35         result = self.execute(sql)
36         if result:
37             # 判断是否删除对应的缓存
38             if is_update_cache:
39                 # 循环删除更新成功的所有记录对应的缓存
40                 for model in result:
41                     self.del_model_for_cache(model.get('id', 0))
42                 # 同步删除与本表关联的缓存
43                 self.del_relevance_cache()
44         return result
45 
46     def delete(self, wheres='', returning='', is_update_cache=True):
47         """
48         批量删除数据库记录
49         :param wheres: 删除条件
50         :param returning: 删除成功后,返回的字段名
51         :param is_update_cache: 是否同步更新缓存
52         :return:
53         """
54         # 如果存在条件
55         if wheres:
56             wheres = ' where ' + wheres
57 
58         # 如果有指定返回参数,则添加
59         if returning:
60             returning = ', ' + returning
61 
62         # 生成sql语句
63         sql = "delete from %(table_name)s %(wheres)s returning %(pk_name)s %(returning)s" % \
64               {'table_name': self.__table_name, 'wheres': wheres, 'pk_name': self.__pk_name, 'returning': returning}
65         result = self.execute(sql)
66         if result:
67             # 同步删除对应的缓存
68             if is_update_cache:
69                 for model in result:
70                     self.del_model_for_cache(model.get('id', 0))
71                 # 同步删除与本表关联的缓存
72                 self.del_relevance_cache()
73         return result
View Code

  

  ORM的缓存改造就全部完成了,下面是完整代码

  1 #!/usr/bin/env python
  2 # coding=utf-8
  3 
  4 from common import db_helper, cache_helper
  5 
  6 
  7 class LogicBase():
  8     """逻辑层基础类"""
  9 
 10     def __init__(self, db, is_output_sql, table_name, column_name_list='*', pk_name='id'):
 11         """类初始化"""
 12         # 数据库参数
 13         self.__db = db
 14         # 是否输出执行的Sql语句到日志中
 15         self.__is_output_sql = is_output_sql
 16         # 表名称
 17         self.__table_name = str(table_name).lower()
 18         # 查询的列字段名称,*表示查询全部字段,多于1个字段时用逗号进行分隔,除了字段名外,也可以是表达式
 19         self.__column_name_list = str(column_name_list).lower()
 20         # 主健名称
 21         self.__pk_name = str(pk_name).lower()
 22         # 缓存列表
 23         self.__cache_list = self.__table_name + '_cache_list'
 24 
 25     #####################################################################
 26     ### 执行Sql ###
 27 
 28     def select(self, sql):
 29         """执行sql查询语句(select)"""
 30         with db_helper.PgHelper(self.__db, self.__is_output_sql) as db:
 31             # 执行sql语句
 32             result = db.execute(sql)
 33             if not result:
 34                 result = []
 35         return result
 36 
 37     def execute(self, sql):
 38         """执行sql语句,并提交事务"""
 39         with db_helper.PgHelper(self.__db, self.__is_output_sql) as db:
 40             # 执行sql语句
 41             result = db.execute(sql)
 42             if result:
 43                 db.commit()
 44             else:
 45                 result = []
 46         return result
 47 
 48     def copy(self, values, columns):
 49         """批量更新数据"""
 50         with db_helper.PgHelper(self.__db, self.__is_output_sql) as db:
 51             # 执行sql语句
 52             result = db.copy(values, self.__table_name, columns)
 53         return result
 54 
 55     def get_model(self, wheres):
 56         """通过条件获取一条记录"""
 57         # 如果有条件,则自动添加where
 58         if wheres:
 59             wheres = ' where ' + wheres
 60 
 61         # 合成sql语句
 62         sql = "select %(column_name_list)s from %(table_name)s %(wheres)s" % \
 63               {'column_name_list': self.__column_name_list, 'table_name': self.__table_name, 'wheres': wheres}
 64         # 初化化数据库链接
 65         result = self.select(sql)
 66         if result:
 67             return result[0]
 68         return {}
 69 
 70     def get_model_for_pk(self, pk, wheres=''):
 71         """通过主键值获取数据库记录实体"""
 72         if not pk:
 73             return {}
 74         # 组装查询条件
 75         wheres = '%s = %s' % (self.__pk_name, str(pk))
 76 
 77         return self.get_model(wheres)
 78 
 79     def get_value(self, column_name, wheres=''):
 80         """
 81         获取指定条件的字段值————多于条记录时,只取第一条记录
 82         :param column_name: 单个字段名,如:id
 83         :param wheres: 查询条件
 84         :return: 7 (指定的字段值)
 85         """
 86         if not column_name:
 87             return None
 88         elif wheres:
 89             wheres = ' where ' + wheres
 90 
 91         sql = 'select %(column_name)s from %(table_name)s %(wheres)s limit 1' % \
 92               {'column_name': column_name, 'table_name': self.__table_name, 'wheres': wheres}
 93         result = self.select(sql)
 94         # 如果查询成功,则直接返回记录字典
 95         if result:
 96             return result[0].get(column_name)
 97 
 98     def get_value_list(self, column_name, wheres=''):
 99         """
100         获取指定条件记录的字段值列表
101         :param column_name: 单个字段名,如:id
102         :param wheres: 查询条件
103         :return: [1,3,4,6,7]
104         """
105         if not column_name:
106             column_name = self.__pk_name
107         elif wheres:
108             wheres = ' where ' + wheres
109 
110         sql = 'select array_agg(%(column_name)s) as list from %(table_name)s %(wheres)s' % \
111               {'column_name': column_name, 'table_name': self.__table_name, 'wheres': wheres}
112         result = self.select(sql)
113         # 如果查询失败或不存在指定条件记录,则直接返回初始值
114         if result and isinstance(result, list):
115             return result[0].get('list')
116         else:
117             return []
118 
119     def add_model(self, fields, returning=''):
120         """新增数据库记录"""
121         ### 拼接sql语句 ###
122         # 初始化变量
123         key_list = []
124         value_list = []
125         # 将传入的字典参数进行处理,把字段名生成sql插入字段名数组和字典替换数组
126         # PS:字符串使用字典替换参数时,格式是%(name)s,这里会生成对应的字串
127         # 比如:
128         #   传入的字典为: {'id': 1, 'name': '名称'}
129         #   那么生成的key_list为:'id','name'
130         #   而value_list为:'%(id)s,%(name)s'
131         #   最终而value_list为字符串对应名称位置会被替换成相应的值
132         for key in fields.keys():
133             key_list.append(key)
134             value_list.append('%(' + key + ')s')
135         # 设置sql拼接字典,并将数组(lit)使用join方式进行拼接,生成用逗号分隔的字符串
136         parameter = {
137             'table_name': self.__table_name,
138             'pk_name': self.__pk_name,
139             'key_list': ','.join(key_list),
140             'value_list': ','.join(value_list)
141         }
142         # 如果有指定返回参数,则添加
143         if returning:
144             parameter['returning'] = ', ' + returning
145         else:
146             parameter['returning'] = ''
147 
148         # 生成可以使用字典替换的字符串
149         sql = "insert into %(table_name)s (%(key_list)s) values (%(value_list)s) returning %(pk_name)s %(returning)s" % parameter
150         # 将生成好的字符串替字典参数值,生成最终可执行的sql语句
151         sql = sql % fields
152 
153         result = self.execute(sql)
154         if result:
155             return result[0]
156         return {}
157 
158     def edit(self, fields, wheres='', returning='', is_update_cache=True):
159         """
160         批量编辑数据库记录
161         :param fields: 要更新的字段(字段名与值存储在字典中)
162         :param wheres: 更新条件
163         :param returning: 更新成功后,返回的字段名
164         :param is_update_cache: 是否同步更新缓存
165         :return:
166         """
167         ### 拼接sql语句 ###
168         # 拼接字段与值
169         field_list = [key + ' = %(' + key + ')s' for key in fields.keys()]
170         # 设置sql拼接字典
171         parameter = {
172             'table_name': self.__table_name,
173             'pk_name': self.__pk_name,
174             'field_list': ','.join(field_list)
175         }
176         # 如果存在更新条件,则将条件添加到sql拼接更换字典中
177         if wheres:
178             parameter['wheres'] = ' where ' + wheres
179         else:
180             parameter['wheres'] = ''
181 
182         # 如果有指定返回参数,则添加
183         if returning:
184             parameter['returning'] = ', ' + returning
185         else:
186             parameter['returning'] = ''
187 
188         # 生成sql语句
189         sql = "update %(table_name)s set %(field_list)s %(wheres)s returning %(pk_name)s %(returning)s" % parameter
190         sql = sql % fields
191 
192         result = self.execute(sql)
193         if result:
194             # 判断是否删除对应的缓存
195             if is_update_cache:
196                 # 循环删除更新成功的所有记录对应的缓存
197                 for model in result:
198                     self.del_model_for_cache(model.get('id', 0))
199                 # 同步删除与本表关联的缓存
200                 self.del_relevance_cache()
201         return result
202 
203     def edit_model(self, pk, fields, wheres='', returning=''):
204         """编辑单条数据库记录"""
205         if not pk:
206             return {}
207         elif wheres:
208             wheres = self.__pk_name + ' = ' + str(pk) + ' and ' + wheres
209         else:
210             wheres = self.__pk_name + ' = ' + str(pk)
211 
212         return self.edit(fields, wheres, returning)
213 
214     def delete(self, wheres='', returning='', is_update_cache=True):
215         """
216         批量删除数据库记录
217         :param wheres: 删除条件
218         :param returning: 删除成功后,返回的字段名
219         :param is_update_cache: 是否同步更新缓存
220         :return:
221         """
222         # 如果存在条件
223         if wheres:
224             wheres = ' where ' + wheres
225 
226         # 如果有指定返回参数,则添加
227         if returning:
228             returning = ', ' + returning
229 
230         # 生成sql语句
231         sql = "delete from %(table_name)s %(wheres)s returning %(pk_name)s %(returning)s" % \
232               {'table_name': self.__table_name, 'wheres': wheres, 'pk_name': self.__pk_name, 'returning': returning}
233         result = self.execute(sql)
234         if result:
235             # 同步删除对应的缓存
236             if is_update_cache:
237                 for model in result:
238                     self.del_model_for_cache(model.get('id', 0))
239                 # 同步删除与本表关联的缓存
240                 self.del_relevance_cache()
241         return result
242 
243     def delete_model(self, pk, wheres='', returning='', is_update_cache=True):
244         """删除单条数据库记录"""
245         if not pk:
246             return {}
247         elif wheres:
248             wheres = self.__pk_name + ' = ' + str(pk) + ' and ' + wheres
249         else:
250             wheres = self.__pk_name + ' = ' + str(pk)
251 
252         return self.delete(wheres, returning)
253 
254     def get_list(self, column_name_list='', wheres='', page_number=None, page_size=None, orderby=None, table_name=None):
255         """
256         获取指定条件的数据库记录集
257         :param column_name_list:      查询字段
258         :param wheres:      查询条件
259         :param page_number:   分页索引值
260         :param page_size:    分页大小, 存在值时才会执行分页
261         :param orderby:     排序规则
262         :param table_name:     查询数据表,多表查询时需要设置
263         :return: 返回记录集总数量与分页记录集
264             {'records': 0, 'total': 0, 'page': 0, 'rows': []}
265         """
266         # 初始化输出参数:总记录数量与列表集
267         data = {
268             'records': 0,  # 总记录数
269             'total': 0,  # 总页数
270             'page': 1,  # 当前页面索引
271             'rows': [],  # 查询结果(记录列表)
272         }
273         # 初始化查询数据表名称
274         if not table_name:
275             table_name = self.__table_name
276         # 初始化查询字段名
277         if not column_name_list:
278             column_name_list = self.__column_name_list
279         # 初始化查询条件
280         if wheres:
281             # 如果是字符串,表示该查询条件已组装好了,直接可以使用
282             if isinstance(wheres, str):
283                 wheres = 'where ' + wheres
284             # 如果是list,则表示查询条件有多个,可以使用join将它们用and方式组合起来使用
285             elif isinstance(wheres, list):
286                 wheres = 'where ' + ' and '.join(wheres)
287         # 初始化排序
288         if not orderby:
289             orderby = self.__pk_name + ' desc'
290         # 初始化分页查询的记录区间
291         paging = ''
292 
293         with db_helper.PgHelper(self.__db, self.__is_output_sql) as db:
294             #############################################################
295             # 判断是否需要进行分页
296             if not page_size is None:
297                 ### 执行sql,获取指定条件的记录总数量
298                 sql = 'select count(1) as records from %(table_name)s %(wheres)s ' % \
299                       {'table_name': table_name, 'wheres': wheres}
300                 result = db.execute(sql)
301                 # 如果查询失败或不存在指定条件记录,则直接返回初始值
302                 if not result or result[0]['records'] == 0:
303                     return data
304 
305                 # 设置记录总数量
306                 data['records'] = result[0].get('records')
307 
308                 #########################################################
309                 ### 设置分页索引与页面大小 ###
310                 if page_size <= 0:
311                     page_size = 10
312                 # 计算总分页数量:通过总记录数除于每页显示数量来计算总分页数量
313                 if data['records'] % page_size == 0:
314                     page_total = data['records'] // page_size
315                 else:
316                     page_total = data['records'] // page_size + 1
317                 # 判断页码是否超出限制,超出限制查询时会出现异常,所以将页面索引设置为最后一页
318                 if page_number < 1 or page_number > page_total:
319                     page_number = page_total
320                 # 记录总页面数量
321                 data['total'] = page_total
322                 # 记录当前页面值
323                 data['page'] = page_number
324                 # 计算当前页面要显示的记录起始位置(limit指定的位置)
325                 record_number = (page_number - 1) * page_size
326                 # 设置查询分页条件
327                 paging = ' limit ' + str(page_size) + ' offset ' + str(record_number)
328             #############################################################
329 
330             ### 按条件查询数据库记录
331             sql = "select %(column_name_list)s from %(table_name)s %(wheres)s order by %(orderby)s %(paging)s" % \
332                   {'column_name_list': column_name_list,
333                    'table_name': table_name,
334                    'wheres': wheres,
335                    'orderby': orderby,
336                    'paging': paging}
337             result = db.execute(sql)
338             if result:
339                 data['rows'] = result
340                 # 不需要分页查询时,直接在这里设置总记录数
341                 if page_size is None:
342                     data['records'] = len(result)
343 
344         return data
345 
346     def get_count(self, wheres=''):
347         """获取指定条件记录数量"""
348         if wheres:
349             wheres = ' where ' + wheres
350         sql = 'select count(1) as total from %(table_name)s %(wheres)s ' % \
351               {'table_name': self.__table_name, 'wheres': wheres}
352         result = self.select(sql)
353         # 如果查询存在记录,则返回true
354         if result:
355             return result[0].get('total')
356         return 0
357 
358     def get_sum(self, fields, wheres):
359         """获取指定条件记录数量"""
360         sql = 'select sum(%(fields)s) as total from %(table_name)s where %(wheres)s ' % \
361               {'table_name': self.__table_name, 'wheres': wheres, 'fields': fields}
362         result = self.select(sql)
363         # 如果查询存在记录,则返回true
364         if result and result[0].get('total'):
365             return result[0].get('total')
366         return 0
367 
368     def get_min(self, fields, wheres):
369         """获取该列记录最小值"""
370         sql = 'select min(%(fields)s) as min from %(table_name)s where %(wheres)s ' % \
371               {'table_name': self.__table_name, 'wheres': wheres, 'fields': fields}
372         result = self.select(sql)
373         # 如果查询存在记录,则返回true
374         if result and result[0].get('min'):
375             return result[0].get('min')
376 
377     def get_max(self, fields, wheres):
378         """获取该列记录最大值"""
379         sql = 'select max(%(fields)s) as max from %(table_name)s where %(wheres)s ' % \
380               {'table_name': self.__table_name, 'wheres': wheres, 'fields': fields}
381         result = self.select(sql)
382         # 如果查询存在记录,则返回true
383         if result and result[0].get('max'):
384             return result[0].get('max')
385 
386             #####################################################################
387 
388 
389     #####################################################################
390     ### 缓存操作方法 ###
391 
392     def get_cache_key(self, pk):
393         """获取缓存key值"""
394         return ''.join((self.__table_name, '_', str(pk)))
395 
396     def set_model_for_cache(self, pk, value, time=43200):
397         """更新存储在缓存中的数据库记录,缓存过期时间为12小时"""
398         # 生成缓存key
399         key = self.get_cache_key(pk)
400         # 存储到nosql缓存中
401         cache_helper.set(key, value, time)
402 
403     def get_model_for_cache(self, pk):
404         """从缓存中读取数据库记录"""
405         # 生成缓存key
406         key = self.get_cache_key(pk)
407         # 从缓存中读取数据库记录
408         result = cache_helper.get(key)
409         # 缓存中不存在记录,则从数据库获取
410         if not result:
411             result = self.get_model_for_pk(pk)
412             self.set_model_for_cache(pk, result)
413         if result:
414             return result
415         else:
416             return {}
417 
418     def get_value_for_cache(self, pk, column_name):
419         """获取指定记录的字段值"""
420         return self.get_model_for_cache(pk).get(column_name)
421 
422     def del_model_for_cache(self, pk):
423         """删除缓存中指定数据"""
424         # 生成缓存key
425         key = self.get_cache_key(pk)
426         # log_helper.info(key)
427         # 存储到nosql缓存中
428         cache_helper.delete(key)
429 
430     def add_relevance_cache_in_list(self, key):
431         """将缓存名称存储到列表里————主要存储与记录变更关联的"""
432         # 从nosql中读取全局缓存列表
433         cache_list = cache_helper.get(self.__cache_list)
434         # 判断缓存列表是否有值,有则进行添加操作
435         if cache_list:
436             # 判断是否已存储列表中,不存在则执行添加操作
437             if not key in cache_list:
438                 cache_list.append(key)
439                 cache_helper.set(self.__cache_list, cache_list)
440         # 无则直接创建全局缓存列表,并存储到nosql中
441         else:
442             cache_list = [key]
443             cache_helper.set(self.__cache_list, cache_list)
444 
445     def del_relevance_cache(self):
446         """删除关联缓存————将和数据表记录关联的,个性化缓存全部删除"""
447         # 从nosql中读取全局缓存列表
448         cache_list = cache_helper.get(self.__cache_list)
449         # 清除已删除缓存列表
450         cache_helper.delete(self.__cache_list)
451         if cache_list:
452             # 执行删除操作
453             for cache in cache_list:
454                 cache_helper.delete(cache)
455 
456     #####################################################################
View Code

 

 

版权声明:本文原创发表于 博客园,作者为 AllEmpty 本文欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文连接,否则视为侵权。

python开发QQ群:669058475    作者博客:http://www.cnblogs.com/EmptyFS/

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:Python骚操作!利用Python来爬取IP代理!偷偷给文章刷阅读量!

下一篇:Django视图