EmptyFS

  写到这里,基本的ORM功能就完成了,不知大家有没有发现,这个ORM每个方法都是在with中执行的,也就是说每个方法都是一个完整的事务,当它执行完成以后也会将事务提交,那么如果我们想要进行一个复杂的事务时,它并不能做到,所以我们还需要对它进行改造,让它支持sql事务。

  那么应该怎么实现呢?我们都知道要支持事务,就必须让不同的sql语句在同一个事务中执行,也就是说,我们需要在一个with中执行所有的sql语句,失败则回滚,成功再提交事务。

  由于我们的逻辑层各个类都是继承ORM基类来实现的,而事务的开关放在各个类中就不合适,可能会存在问题,所以在执行事务时,直接调用db_helper模块,使用with初始化好数据库链接,然后在方法里编写并执行各个sql语句。

  当前逻辑层基类(ORM模块)的sql语句都是在方法中生成(拼接)的,然后在方法的with模块中执行,所以我们需要再次对整个类进行改造,将所有的sql生成方法提炼出来,成为单独的方法,然后在事务中,我们不直接执行获取结果,而是通过ORM生成对应的sql语句,在with中执行这样语句。(当然还有其他方法也能实现事务,不过在这里不做进一步的探讨,因为当前这种是最简单实现事务的方式之一,多层封装处理,有可能会导致系统变的更加复杂,代码更加难懂)

  代码改造起来很简单,比如说获取记录方法

 1     def get_model(self, wheres):
 2         """通过条件获取一条记录"""
 3         # 如果有条件,则自动添加where
 4         if wheres:
 5             wheres = ' where ' + wheres
 6 
 7         # 合成sql语句
 8         sql = "select %(column_name_list)s from %(table_name)s %(wheres)s" % \
 9               {'column_name_list': self.__column_name_list, 'table_name': self.__table_name, 'wheres': wheres}
10         # 初化化数据库链接
11         result = self.select(sql)
12         if result:
13             return result[0]
14         return {}

  我们可以将它拆分成get_model_sql()和get_model()两个方法,一个处理sql组合,一个执行获取结果,前者可以给事务调用,后者直接给对应的程序调用

 1     def get_model_sql(self, wheres):
 2         """通过条件获取一条记录"""
 3         # 如果有条件,则自动添加where
 4         if wheres:
 5             wheres = ' where ' + wheres
 6 
 7         # 合成sql语句
 8         sql = "select %(column_name_list)s from %(table_name)s %(wheres)s" % \
 9               {'column_name_list': self.__column_name_list, 'table_name': self.__table_name, 'wheres': wheres}
10         return sql
11 
12     def get_model(self, wheres):
13         """通过条件获取一条记录"""
14         # 生成sql
15         sql = self.get_model_sql(wheres)
16         # 初化化数据库链接
17         result = self.select(sql)
18         if result:
19             return result[0]
20         return {}

  其他代码不一一细述,大家自己看看重构后的结果

  1 #!/usr/bin/env python
  2 # coding=utf-8
  3 
  4 from common import db_helper, cache_helper, encrypt_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     def get_model_sql(self, wheres):
 28         """通过条件获取一条记录"""
 29         # 如果有条件,则自动添加where
 30         if wheres:
 31             wheres = ' where ' + wheres
 32 
 33         # 合成sql语句
 34         sql = "select %(column_name_list)s from %(table_name)s %(wheres)s" % \
 35               {'column_name_list': self.__column_name_list, 'table_name': self.__table_name, 'wheres': wheres}
 36         return sql
 37 
 38     def get_model_for_pk_sql(self, pk, wheres=''):
 39         """通过主键值获取数据库记录实体"""
 40         # 组装查询条件
 41         wheres = '%s = %s' % (self.__pk_name, str(pk))
 42         return self.get_model_sql(wheres)
 43 
 44     def get_value_sql(self, column_name, wheres=''):
 45         """
 46         获取指定条件的字段值————多于条记录时,只取第一条记录
 47         :param column_name: 单个字段名,如:id
 48         :param wheres: 查询条件
 49         :return: 7 (指定的字段值)
 50         """
 51         if wheres:
 52             wheres = ' where ' + wheres
 53 
 54         sql = 'select %(column_name)s from %(table_name)s %(wheres)s limit 1' % \
 55               {'column_name': column_name, 'table_name': self.__table_name, 'wheres': wheres}
 56         return sql
 57 
 58     def get_value_list_sql(self, column_name, wheres=''):
 59         """
 60         获取指定条件记录的字段值列表
 61         :param column_name: 单个字段名,如:id
 62         :param wheres: 查询条件
 63         :return: [1,3,4,6,7]
 64         """
 65         if not column_name:
 66             column_name = self.__pk_name
 67         elif wheres:
 68             wheres = ' where ' + wheres
 69 
 70         sql = 'select array_agg(%(column_name)s) as list from %(table_name)s %(wheres)s' % \
 71               {'column_name': column_name, 'table_name': self.__table_name, 'wheres': wheres}
 72         return sql
 73 
 74     def add_model_sql(self, fields, returning=''):
 75         """新增数据库记录"""
 76         ### 拼接sql语句 ###
 77         # 初始化变量
 78         key_list = []
 79         value_list = []
 80         # 将传入的字典参数进行处理,把字段名生成sql插入字段名数组和字典替换数组
 81         # PS:字符串使用字典替换参数时,格式是%(name)s,这里会生成对应的字串
 82         # 比如:
 83         #   传入的字典为: {'id': 1, 'name': '名称'}
 84         #   那么生成的key_list为:'id','name'
 85         #   而value_list为:'%(id)s,%(name)s'
 86         #   最终而value_list为字符串对应名称位置会被替换成相应的值
 87         for key in fields.keys():
 88             key_list.append(key)
 89             value_list.append('%(' + key + ')s')
 90         # 设置sql拼接字典,并将数组(lit)使用join方式进行拼接,生成用逗号分隔的字符串
 91         parameter = {
 92             'table_name': self.__table_name,
 93             'pk_name': self.__pk_name,
 94             'key_list': ','.join(key_list),
 95             'value_list': ','.join(value_list)
 96         }
 97         # 如果有指定返回参数,则添加
 98         if returning:
 99             parameter['returning'] = ', ' + returning
100         else:
101             parameter['returning'] = ''
102 
103         # 生成可以使用字典替换的字符串
104         sql = "insert into %(table_name)s (%(key_list)s) values (%(value_list)s) returning %(pk_name)s %(returning)s" % parameter
105         # 将生成好的字符串替字典参数值,生成最终可执行的sql语句
106         return sql % fields
107 
108     def edit_sql(self, fields, wheres='', returning=''):
109         """
110         批量编辑数据库记录
111         :param fields: 要更新的字段(字段名与值存储在字典中)
112         :param wheres: 更新条件
113         :param returning: 更新成功后,返回的字段名
114         :param is_update_cache: 是否同步更新缓存
115         :return:
116         """
117         ### 拼接sql语句 ###
118         # 拼接字段与值
119         field_list = [key + ' = %(' + key + ')s' for key in fields.keys()]
120         # 设置sql拼接字典
121         parameter = {
122             'table_name': self.__table_name,
123             'pk_name': self.__pk_name,
124             'field_list': ','.join(field_list)
125         }
126         # 如果存在更新条件,则将条件添加到sql拼接更换字典中
127         if wheres:
128             parameter['wheres'] = ' where ' + wheres
129         else:
130             parameter['wheres'] = ''
131 
132         # 如果有指定返回参数,则添加
133         if returning:
134             parameter['returning'] = ', ' + returning
135         else:
136             parameter['returning'] = ''
137 
138         # 生成sql语句
139         sql = "update %(table_name)s set %(field_list)s %(wheres)s returning %(pk_name)s %(returning)s" % parameter
140         return sql % fields
141 
142     def edit_model_sql(self, pk, fields, wheres='', returning=''):
143         """编辑单条数据库记录"""
144         if wheres:
145             wheres = self.__pk_name + ' = ' + str(pk) + ' and ' + wheres
146         else:
147             wheres = self.__pk_name + ' = ' + str(pk)
148 
149         return self.edit_sql(fields, wheres, returning)
150 
151     def delete_sql(self, wheres='', returning=''):
152         """
153         批量删除数据库记录
154         :param wheres: 删除条件
155         :param returning: 删除成功后,返回的字段名
156         :param is_update_cache: 是否同步更新缓存
157         :return:
158         """
159         # 如果存在条件
160         if wheres:
161             wheres = ' where ' + wheres
162 
163         # 如果有指定返回参数,则添加
164         if returning:
165             returning = ', ' + returning
166 
167         # 生成sql语句
168         sql = "delete from %(table_name)s %(wheres)s returning %(pk_name)s %(returning)s" % \
169               {'table_name': self.__table_name, 'wheres': wheres, 'pk_name': self.__pk_name, 'returning': returning}
170         return sql
171 
172     def delete_model_sql(self, pk, wheres='', returning=''):
173         """删除单条数据库记录"""
174         if wheres:
175             wheres = self.__pk_name + ' = ' + str(pk) + ' and ' + wheres
176         else:
177             wheres = self.__pk_name + ' = ' + str(pk)
178 
179         return self.delete_sql(wheres, returning)
180 
181     def get_list_sql(self, column_name_list='', wheres='', orderby=None, table_name=None):
182         """
183         获取指定条件的数据库记录集
184         :param column_name_list:      查询字段
185         :param wheres:      查询条件
186         :param orderby:     排序规则
187         :param table_name:     查询数据表,多表查询时需要设置
188         :return:
189         """
190         # 初始化查询数据表名称
191         if not table_name:
192             table_name = self.__table_name
193         # 初始化查询字段名
194         if not column_name_list:
195             column_name_list = self.__column_name_list
196         # 初始化查询条件
197         if wheres:
198             # 如果是字符串,表示该查询条件已组装好了,直接可以使用
199             if isinstance(wheres, str):
200                 wheres = 'where ' + wheres
201             # 如果是list,则表示查询条件有多个,可以使用join将它们用and方式组合起来使用
202             elif isinstance(wheres, list):
203                 wheres = 'where ' + ' and '.join(wheres)
204         # 初始化排序
205         if not orderby:
206             orderby = self.__pk_name + ' desc'
207         #############################################################
208 
209         ### 按条件查询数据库记录
210         sql = "select %(column_name_list)s from %(table_name)s %(wheres)s order by %(orderby)s " % \
211               {'column_name_list': column_name_list,
212                'table_name': table_name,
213                'wheres': wheres,
214                'orderby': orderby}
215         return sql
216 
217     def get_count_sql(self, wheres=''):
218         """获取指定条件记录数量"""
219         if wheres:
220             wheres = ' where ' + wheres
221         sql = 'select count(1) as total from %(table_name)s %(wheres)s ' % \
222               {'table_name': self.__table_name, 'wheres': wheres}
223         return sql
224 
225     def get_sum_sql(self, fields, wheres):
226         """获取指定条件记录数量"""
227         sql = 'select sum(%(fields)s) as total from %(table_name)s where %(wheres)s ' % \
228               {'table_name': self.__table_name, 'wheres': wheres, 'fields': fields}
229         return sql
230 
231     def get_min_sql(self, fields, wheres):
232         """获取该列记录最小值"""
233         sql = 'select min(%(fields)s) as min from %(table_name)s where %(wheres)s ' % \
234               {'table_name': self.__table_name, 'wheres': wheres, 'fields': fields}
235         return sql
236 
237     def get_max_sql(self, fields, wheres):
238         """获取该列记录最大值"""
239         sql = 'select max(%(fields)s) as max from %(table_name)s where %(wheres)s ' % \
240               {'table_name': self.__table_name, 'wheres': wheres, 'fields': fields}
241         return sql
242 
243     #####################################################################
244 
245 
246     #####################################################################
247     ### 执行Sql ###
248 
249     def select(self, sql):
250         """执行sql查询语句(select)"""
251         with db_helper.PgHelper(self.__db, self.__is_output_sql) as db:
252             # 执行sql语句
253             result = db.execute(sql)
254             if not result:
255                 result = []
256         return result
257 
258     def execute(self, sql):
259         """执行sql语句,并提交事务"""
260         with db_helper.PgHelper(self.__db, self.__is_output_sql) as db:
261             # 执行sql语句
262             result = db.execute(sql)
263             if result:
264                 db.commit()
265             else:
266                 result = []
267         return result
268 
269     def copy(self, values, columns):
270         """批量更新数据"""
271         with db_helper.PgHelper(self.__db, self.__is_output_sql) as db:
272             # 执行sql语句
273             result = db.copy(values, self.__table_name, columns)
274         return result
275 
276     def get_model(self, wheres):
277         """通过条件获取一条记录"""
278         # 生成sql
279         sql = self.get_model_sql(wheres)
280         # 执行查询操作
281         result = self.select(sql)
282         if result:
283             return result[0]
284         return {}
285 
286     def get_model_for_pk(self, pk, wheres=''):
287         """通过主键值获取数据库记录实体"""
288         if not pk:
289             return {}
290         # 生成sql
291         sql = self.get_model_for_pk_sql(pk, wheres)
292         # 执行查询操作
293         result = self.select(sql)
294         if result:
295             return result[0]
296         return {}
297 
298     def get_value(self, column_name, wheres=''):
299         """
300         获取指定条件的字段值————多于条记录时,只取第一条记录
301         :param column_name: 单个字段名,如:id
302         :param wheres: 查询条件
303         :return: 7 (指定的字段值)
304         """
305         if not column_name:
306             return None
307 
308         # 生成sql
309         sql = self.get_value_sql(column_name, wheres)
310         result = self.select(sql)
311         # 如果查询成功,则直接返回记录字典
312         if result:
313             return result[0].get(column_name)
314 
315     def get_value_list(self, column_name, wheres=''):
316         """
317         获取指定条件记录的字段值列表
318         :param column_name: 单个字段名,如:id
319         :param wheres: 查询条件
320         :return: [1,3,4,6,7]
321         """
322         # 生成sql
323         sql = self.get_value_list_sql(column_name, wheres)
324         result = self.select(sql)
325         # 如果查询失败或不存在指定条件记录,则直接返回初始值
326         if result and isinstance(result, list):
327             return result[0].get('list')
328         else:
329             return []
330 
331     def add_model(self, fields, returning=''):
332         """新增数据库记录"""
333         # 生成sql
334         sql = self.add_model_sql(fields, returning)
335         result = self.execute(sql)
336         if result:
337             return result[0]
338         return {}
339 
340     def edit(self, fields, wheres='', returning='', is_update_cache=True):
341         """
342         批量编辑数据库记录
343         :param fields: 要更新的字段(字段名与值存储在字典中)
344         :param wheres: 更新条件
345         :param returning: 更新成功后,返回的字段名
346         :param is_update_cache: 是否同步更新缓存
347         :return:
348         """
349         # 生成sql
350         sql = self.edit_sql(fields, wheres, returning)
351         result = self.execute(sql)
352         if result:
353             # 判断是否删除对应的缓存
354             if is_update_cache:
355                 # 循环删除更新成功的所有记录对应的缓存
356                 for model in result:
357                     self.del_model_for_cache(model.get(self.__pk_name, 0))
358                 # 同步删除与本表关联的缓存
359                 self.del_relevance_cache()
360         return result
361 
362     def edit_model(self, pk, fields, wheres='', returning='', is_update_cache=True):
363         """编辑单条数据库记录"""
364         if not pk:
365             return {}
366         # 生成sql
367         sql = self.edit_model_sql(pk, fields, wheres, returning)
368         result = self.execute(sql)
369         if result:
370             # 判断是否删除对应的缓存
371             if is_update_cache:
372                 # 删除更新成功的所有记录对应的缓存
373                 self.del_model_for_cache(result[0].get(self.__pk_name, 0))
374                 # 同步删除与本表关联的缓存
375                 self.del_relevance_cache()
376         return result
377 
378     def delete(self, wheres='', returning='', is_update_cache=True):
379         """
380         批量删除数据库记录
381         :param wheres: 删除条件
382         :param returning: 删除成功后,返回的字段名
383         :param is_update_cache: 是否同步更新缓存
384         :return:
385         """
386         # 生成sql
387         sql = self.delete_sql(wheres, returning)
388         result = self.execute(sql)
389         if result:
390             # 同步删除对应的缓存
391             if is_update_cache:
392                 for model in result:
393                     self.del_model_for_cache(model.get(self.__pk_name, 0))
394                 # 同步删除与本表关联的缓存
395                 self.del_relevance_cache()
396         return result
397 
398     def delete_model(self, pk, wheres='', returning='', is_update_cache=True):
399         """删除单条数据库记录"""
400         if not pk:
401             return {}
402         # 生成sql
403         sql = self.delete_model_sql(pk, wheres, returning)
404         result = self.execute(sql)
405         if result:
406             # 同步删除对应的缓存
407             if is_update_cache:
408                 self.del_model_for_cache(result[0].get(self.__pk_name, 0))
409                 # 同步删除与本表关联的缓存
410                 self.del_relevance_cache()
411         return result
412 
413     def get_list(self, column_name_list='', wheres='', page_number=None, page_size=None, orderby=None, table_name=None):
414         """
415         获取指定条件的数据库记录集
416         :param column_name_list:      查询字段
417         :param wheres:      查询条件
418         :param page_number:   分页索引值
419         :param page_size:    分页大小, 存在值时才会执行分页
420         :param orderby:     排序规则
421         :param table_name:     查询数据表,多表查询时需要设置
422         :return: 返回记录集总数量与分页记录集
423             {'records': 0, 'total': 0, 'page': 0, 'rows': []}
424         """
425         # 初始化输出参数:总记录数量与列表集
426         data = {
427             'records': 0,  # 总记录数
428             'total': 0,  # 总页数
429             'page': 1,  # 当前页面索引
430             'rows': [],  # 查询结果(记录列表)
431         }
432         # 初始化查询数据表名称
433         if not table_name:
434             table_name = self.__table_name
435         # 初始化查询字段名
436         if not column_name_list:
437             column_name_list = self.__column_name_list
438         # 初始化查询条件
439         if wheres:
440             # 如果是字符串,表示该查询条件已组装好了,直接可以使用
441             if isinstance(wheres, str):
442                 wheres = 'where ' + wheres
443             # 如果是list,则表示查询条件有多个,可以使用join将它们用and方式组合起来使用
444             elif isinstance(wheres, list):
445                 wheres = 'where ' + ' and '.join(wheres)
446         # 初始化排序
447         if not orderby:
448             orderby = self.__pk_name + ' desc'
449         # 初始化分页查询的记录区间
450         paging = ''
451 
452         with db_helper.PgHelper(self.__db, self.__is_output_sql) as db:
453             #############################################################
454             # 判断是否需要进行分页
455             if not page_size is None:
456                 ### 执行sql,获取指定条件的记录总数量
457                 sql = 'select count(1) as records from %(table_name)s %(wheres)s ' % \
458                       {'table_name': table_name, 'wheres': wheres}
459                 result = db.execute(sql)
460                 # 如果查询失败或不存在指定条件记录,则直接返回初始值
461                 if not result or result[0]['records'] == 0:
462                     return data
463 
464                 # 设置记录总数量
465                 data['records'] = result[0].get('records')
466 
467                 #########################################################
468                 ### 设置分页索引与页面大小 ###
469                 if page_size <= 0:
470                     page_size = 10
471                 # 计算总分页数量:通过总记录数除于每页显示数量来计算总分页数量
472                 if data['records'] % page_size == 0:
473                     page_total = data['records'] // page_size
474                 else:
475                     page_total = data['records'] // page_size + 1
476                 # 判断页码是否超出限制,超出限制查询时会出现异常,所以将页面索引设置为最后一页
477                 if page_number < 1 or page_number > page_total:
478                     page_number = page_total
479                 # 记录总页面数量
480                 data['total'] = page_total
481                 # 记录当前页面值
482                 data['page'] = page_number
483                 # 计算当前页面要显示的记录起始位置(limit指定的位置)
484                 record_number = (page_number - 1) * page_size
485                 # 设置查询分页条件
486                 paging = ' limit ' + str(page_size) + ' offset ' + str(record_number)
487             #############################################################
488 
489             ### 按条件查询数据库记录
490             sql = "select %(column_name_list)s from %(table_name)s %(wheres)s order by %(orderby)s %(paging)s" % \
491                   {'column_name_list': column_name_list,
492                    'table_name': table_name,
493                    'wheres': wheres,
494                    'orderby': orderby,
495                    'paging': paging}
496             result = db.execute(sql)
497             if result:
498                 data['rows'] = result
499                 # 不需要分页查询时,直接在这里设置总记录数
500                 if page_size is None:
501                     data['records'] = len(result)
502 
503         return data
504 
505     def get_count(self, wheres=''):
506         """获取指定条件记录数量"""
507         # 生成sql
508         sql = self.get_count_sql(wheres)
509         result = self.select(sql)
510         # 如果查询存在记录,则返回true
511         if result:
512             return result[0].get('total')
513         return 0
514 
515     def get_sum(self, fields, wheres):
516         """获取指定条件记录数量"""
517         # 生成sql
518         sql = self.get_sum_sql(fields, wheres)
519         result = self.select(sql)
520         # 如果查询存在记录,则返回true
521         if result and result[0].get('total'):
522             return result[0].get('total')
523         return 0
524 
525     def get_min(self, fields, wheres):
526         """获取该列记录最小值"""
527         # 生成sql
528         sql = self.get_min_sql(fields, wheres)
529         result = self.select(sql)
530         # 如果查询存在记录,则返回true
531         if result and result[0].get('min'):
532             return result[0].get('min')
533 
534     def get_max(self, fields, wheres):
535         """获取该列记录最大值"""
536         # 生成sql
537         sql = self.get_max_sql(fields, wheres)
538         result = self.select(sql)
539         # 如果查询存在记录,则返回true
540         if result and result[0].get('max'):
541             return result[0].get('max')
542 
543     #####################################################################
544 
545 
546     #####################################################################
547     ### 缓存操作方法 ###
548 
549     def get_cache_key(self, pk):
550         """获取缓存key值"""
551         return ''.join((self.__table_name, '_', str(pk)))
552 
553     def set_model_for_cache(self, pk, value, time=43200):
554         """更新存储在缓存中的数据库记录,缓存过期时间为12小时"""
555         # 生成缓存key
556         key = self.get_cache_key(pk)
557         # 存储到nosql缓存中
558         cache_helper.set(key, value, time)
559 
560     def get_model_for_cache(self, pk):
561         """从缓存中读取数据库记录"""
562         # 生成缓存key
563         key = self.get_cache_key(pk)
564         # 从缓存中读取数据库记录
565         result = cache_helper.get(key)
566         # 缓存中不存在记录,则从数据库获取
567         if not result:
568             result = self.get_model_for_pk(pk)
569             self.set_model_for_cache(pk, result)
570         if result:
571             return result
572         else:
573             return {}
574 
575     def get_model_for_cache_of_where(self, where):
576         """
577         通过条件获取记录实体(我们经常需要使用key、编码或指定条件来获取记录,这时可以通过当前方法来获取)
578         :param where: 查询条件
579         :return: 记录实体
580         """
581         # 生成实体缓存key
582         model_cache_key = self.__table_name + encrypt_helper.md5(where)
583         # 通过条件从缓存中获取记录id
584         pk = cache_helper.get(model_cache_key)
585         # 如果主键id存在,则直接从缓存中读取记录
586         if pk:
587             return self.get_model_for_cache(pk)
588 
589         # 否则从数据库中获取
590         result = self.get_model(where)
591         if result:
592             # 存储条件对应的主键id值到缓存中
593             cache_helper.set(model_cache_key, result.get(self.__pk_name))
594             # 存储记录实体到缓存中
595             self.set_model_for_cache(result.get(self.__pk_name), result)
596             return result
597 
598     def get_value_for_cache(self, pk, column_name):
599         """获取指定记录的字段值"""
600         return self.get_model_for_cache(pk).get(column_name)
601 
602     def del_model_for_cache(self, pk):
603         """删除缓存中指定数据"""
604         # 生成缓存key
605         key = self.get_cache_key(pk)
606         # log_helper.info(key)
607         # 存储到nosql缓存中
608         cache_helper.delete(key)
609 
610     def add_relevance_cache_in_list(self, key):
611         """将缓存名称存储到列表里————主要存储与记录变更关联的"""
612         # 从nosql中读取全局缓存列表
613         cache_list = cache_helper.get(self.__cache_list)
614         # 判断缓存列表是否有值,有则进行添加操作
615         if cache_list:
616             # 判断是否已存储列表中,不存在则执行添加操作
617             if not key in cache_list:
618                 cache_list.append(key)
619                 cache_helper.set(self.__cache_list, cache_list)
620         # 无则直接创建全局缓存列表,并存储到nosql中
621         else:
622             cache_list = [key]
623             cache_helper.set(self.__cache_list, cache_list)
624 
625     def del_relevance_cache(self):
626         """删除关联缓存————将和数据表记录关联的,个性化缓存全部删除"""
627         # 从nosql中读取全局缓存列表
628         cache_list = cache_helper.get(self.__cache_list)
629         # 清除已删除缓存列表
630         cache_helper.delete(self.__cache_list)
631         if cache_list:
632             # 执行删除操作
633             for cache in cache_list:
634                 cache_helper.delete(cache)
635 
636     #####################################################################
View Code

  从完整代码可以看到,重构后的类多了很多sql生成方法,它们其实是从原方法中分享出sql合成代码,将它们独立出来而已。

 

  接下来我们编写单元测试代码,执行一下事务看看效果

 1 #!/usr/bin/evn python
 2 # coding=utf-8
 3 
 4 import unittest
 5 from common import db_helper
 6 from common.string_helper import string
 7 from config import db_config
 8 from logic import product_logic, product_class_logic
 9 
10 
11 class DbHelperTest(unittest.TestCase):
12     """数据库操作包测试类"""
13 
14     def setUp(self):
15         """初始化测试环境"""
16         print('------ini------')
17 
18     def tearDown(self):
19         """清理测试环境"""
20         print('------clear------')
21 
22     def test(self):
23         ##############################################
24         # 只需要看这里,其他代码是测试用例的模板代码 #
25         ##############################################
26         # 测试事务
27         # 使用with方法,初始化数据库链接
28         with db_helper.PgHelper(db_config.DB, db_config.IS_OUTPUT_SQL) as db:
29             # 实例化product表操作类ProductLogic
30             _product_logic = product_logic.ProductLogic()
31             # 实例化product_class表操作类product_class_logic
32             _product_class_logic = product_class_logic.ProductClassLogic()
33             # 初始化产品分类主键id
34             id = 1
35 
36             # 获取产品分类信息(为了查看效果,所以加了这段获取分类信息)
37             sql = _product_class_logic.get_model_for_pk_sql(id)
38             print(sql)
39             # 执行sql语句
40             result = db.execute(sql)
41             if not result:
42                 print('不存在指定的产品分类')
43                 return
44             print('----产品分类实体----')
45             print(result)
46             print('-------------------')
47 
48             # 禁用产品分类
49             fields = {
50                 'is_enable': 0
51             }
52             sql = _product_class_logic.edit_model_sql(id, fields, returning='is_enable')
53             print(sql)
54             # 执行sql语句
55             result = db.execute(sql)
56             if not result:
57                 # 执行失败,执行回滚操作
58                 db.rollback()
59                 print('禁用产品分类失败')
60                 return
61             # 执行缓存清除操作
62             _product_class_logic.del_model_for_cache(id)
63             _product_class_logic.del_relevance_cache()
64             print('----执行成功后的产品分类实体----')
65             print(result)
66             print('-------------------------------')
67 
68             # 同步禁用产品分类对应的所有产品
69             sql = _product_logic.edit_sql(fields, 'product_class_id=' + str(id), returning='is_enable')
70             print(sql)
71             # 执行sql语句
72             result = db.execute(sql)
73             if not result:
74                 # 执行失败,执行回滚操作
75                 db.rollback()
76                 print('同步禁用产品分类对应的所有产品失败')
77                 return
78             # 执行缓存清除操作
79             for model in result:
80                 _product_class_logic.del_model_for_cache(model.get('id'))
81             _product_class_logic.del_relevance_cache()
82             print('----执行成功后的产品实体----')
83             print(result)
84             print('---------------------------')
85 
86             db.commit()
87             print('执行成功')
88         ##############################################
89 
90 if __name__ == '__main__':
91     unittest.main()

  细心的朋友可能会发现,在事务处理中,进行编辑操作以后,会执行缓存的清除操作,这是因为我们在ORM中所绑定的缓存自动清除操作,是在对应的执行方法中,而不是sql生成方法里,所以在进行事务时,如果你使用了缓存的方法,在这里就需要手动添加清除缓存操作,不然就会产生脏数据。

 

  执行结果:

 1 ------ini------
 2 select * from product_class  where id = 1
 3 ----产品分类实体----
 4 [{'add_time': datetime.datetime(2018, 8, 17, 16, 14, 54), 'id': 1, 'is_enable': 1, 'name': '饼干'}]
 5 -------------------
 6 update product_class set is_enable = 0  where id = 1 returning id , is_enable
 7 ----执行成功后的产品分类实体----
 8 [{'id': 1, 'is_enable': 0}]
 9 -------------------------------
10 update product set is_enable = 0  where product_class_id=1 returning id , is_enable
11 ----执行成功后的产品实体----
12 [{'id': 2, 'is_enable': 0}, {'id': 7, 'is_enable': 0}, {'id': 14, 'is_enable': 0}, {'id': 15, 'is_enable': 0}]
13 ---------------------------
14 执行成功
15 ------clear------

 

 

  本文对应的源码下载(一些接口进行了重构,有些还没有处理,所以源码可能直接运行不了,下一章节会讲到所有代码使用ORM模块重构内容)

 

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

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

 

相关文章: