No Description
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

ledatasourcesql.py 4.1KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899
  1. #-*- coding: utf-8 -*-
  2. from leobject.datasources.dummy import DummyDatasource
  3. from mosql.db import Database, all_to_dicts
  4. from mosql.query import select
  5. from leobject import REL_SUB, REL_SUP
  6. from Lodel.utils.mosql import *
  7. ## SQL DataSource for LeObject
  8. class LeDataSourceSQL(DummyDatasource):
  9. RELATIONS_TABLE_NAME = 'relations'
  10. RELATIONS_POSITIONS_FIELDS = {REL_SUP:'superior_id', REL_SUB:'subordinate_id'}
  11. def __init__(self, module=None, *conn_args, **conn_kargs):
  12. super(LeDataSourceSQL, self).__init__()
  13. self.db = Database(self.module, self.conn_args, self.conn_kargs)
  14. ## @brief update an existing object's data
  15. # @param letype LeType
  16. # @param leclass LeClass
  17. # @param filters list : list of tuples formatted as (FIELD, OPERATOR, VALUE)
  18. # @param rel_filters list : list of tuples formatted as (('superior'|'subordinate', FIELD), OPERATOR, VALUE)
  19. # @param data dict
  20. # @return bool
  21. def update(self, letype, leclass, filters, rel_filters, data):
  22. pass
  23. ## @brief create a new object in the datasource
  24. # @param letype LeType
  25. # @param leclass LeClass
  26. # @param datas dict : dictionnary of field:value pairs to save
  27. # @return int : lodel_id of the created object
  28. def insert(self, letype, leclass, **datas):
  29. pass
  30. ## @brief delete an existing object
  31. # @param letype LeType
  32. # @param leclass LeClass
  33. # @param filters list : list of tuples formatted as (FIELD, OPERATOR, VALUE)
  34. # @param relational_filters list : list of tuples formatted as (('superior'|'subordinate', FIELD), OPERATOR, VALUE)
  35. # @return bool : True on success
  36. def delete(self, letype, leclass, filters, relational_filters):
  37. pass
  38. ## @brief search for a collection of objects
  39. # @param leclass LeClass
  40. # @param letype LeType
  41. # @field_list list
  42. # @param filters list : list of tuples formatted as (FIELD, OPERATOR, VALUE)
  43. # @param relational_filters list : list of tuples formatted as (('superior'|'subordinate', FIELD), OPERATOR, VALUE)
  44. # @return list
  45. def get(self, leclass, letype, field_list, filters, relational_filters=None):
  46. query_table_name = leclass.name
  47. where_filters = self._prepare_filters(filters)
  48. join_fields = {}
  49. if relational_filters or len(relational_filters) > 0:
  50. for relational_filter in relational_filters:
  51. # Parsing the relation_filter
  52. relational_position = relational_filter[0][0]
  53. relational_field = relational_filter[0][1]
  54. relational_operator = relational_filter[1]
  55. relational_value = relational_filter[2]
  56. relational_where_filters_key = (relational_field, relational_operator)
  57. relational_where_filters_value = relational_value
  58. # Definition of the join condition
  59. relation_table_join_field = "%s.%s" % (self.RELATIONS_TABLE_NAME, self.RELATIONS_POSITIONS_FIELDS[relational_position])
  60. query_table_join_field = "%s.lodel_id" % query_table_name
  61. join_fields[query_table_join_field] = relation_table_join_field
  62. # Adding "where" filters
  63. where_filters[relational_where_filters_key] = relational_where_filters_value
  64. # Building the query
  65. query = select(query_table_name, where=where_filters, select=field_list, joins=join(self.RELATIONS_TABLE_NAME, join_fields))
  66. else:
  67. query = select(query_table_name, where=where_filters, select=field_list)
  68. # Executing the query
  69. self.db.execute(query)
  70. # Returning it as a list of dict
  71. return all_to_dicts(self.db)
  72. # @brief prepares the filters to be used by the mosql library's functions
  73. # @params filters : (FIELD, OPERATOR, VALUE) tuples
  74. # @return dict : Dictionnary with (FIELD, OPERATOR):VALUE style elements
  75. def _prepare_filters(self, filters):
  76. prepared_filters = {}
  77. for filter in filters:
  78. prepared_filter_key = (filter[0], filter[1])
  79. prepared_filter_value = filter[2]
  80. prepared_filters[prepared_filter_key] = prepared_filter_value
  81. return prepared_filters