डेटा ऑब्जेक्ट प्रतिनिधित्व

ऑब्जेक्ट डेटा प्रस्तुति

शुभ दोपहर इस ब्लॉग में, मैं एक ही प्रकार की वस्तुओं के एक सेट के रूप में डेटा की प्रस्तुति के बारे में बात करना चाहूंगा। डेटाबेस के लिए एक क्वेरी का परिणाम ट्यूपल्स की एक सूची द्वारा प्रस्तुत किया जा सकता है, या तो नाम अनुक्रमों (शब्दकोशों) की एक सूची के रूप में, जो बाद में आवेदन में उपयोग किया जाता है, और एक अनुक्रम के तत्वों तक पहुंच या तो सूचकांक या विशेषता नाम से होती है। आइए उन वस्तुओं की सूची प्राप्त करने का प्रयास करें जिनके पास हैं:

• विशेषताएँ जिनके नाम तालिका फ़ील्ड्स के नाम के साथ मेल खाते हैं (क्वेरी में कॉलम का नाम)
• सरल डेटा प्रोसेसिंग के तरीके

जटिल प्रश्नों के लिए, इस तंत्र का उपयोग सबसे अधिक उचित नहीं होगा, लेकिन यह संदर्भ डेटा के साथ काम करने के लिए काफी उपयुक्त है। आइए अजगर को एक प्रोग्रामिंग कॉल के रूप में लेते हैं।

तो चलिए शुरू करते हैं।

प्रारंभिक शर्तें

हमारे डेटाबेस में हमारे पास बस्तियों की एक तालिका है। प्रत्येक रिकॉर्ड के लिए, एक प्राथमिक कुंजी, एक नाम, समय क्षेत्र के लिए एक सुधार और लाइन गतिविधि का एक संकेत परिभाषित किया गया है।

CREATE TABLE dicts.points ( id_point serial NOT NULL, --    "name" character varying(50) DEFAULT ''::character varying, --  sync_hour integer DEFAULT 0, --    ... is_active boolean DEFAULT true, --   CONSTRAINT pk_points PRIMARY KEY (id_point) ); 

आवेदन कोड

डेटाबेस कनेक्शन मॉड्यूल

हम PostgreSQL के साथ काम करने के लिए विहित पीजी मॉड्यूल का उपयोग करेंगे।

 import pg class Connection: """       DB API2 """ def __init__(self,dbname,user,password,host,port): self.dbname = dbname self.user = user self.password = password self.host = host self.port = port self.db = None #      self.query_collector = None #     self.err = '' #     def Connect(self): """     """ try: self.db = pg.DB(dbname=self.dbname,user=self.user,passwd=self.password,host=self.host,port=self.port) except Exception,err: raise Exception("    : %s" % err.message) def Disconnect(self): self.db.close() def SendQueryReturn(self,query): """  SELECT- """ try: self.query_collector = self.db.query(query) except ProgrammingError,err: self.err = " %s:    \n %s" % (__name__,err.message) return -1 else: return self.query_collector.ntuples() def SendQueryNoreturn(self,query): """  ,    """ try: self.db.query(query) except ProgrammingError,err: self.err = " %s:    \n %s" % (__name__,err.message) return -1 else: return 0 def SendBEGIN(self): """   """ try: self.db.query("BEGIN") except ProgrammingError,err: self.err = " %s:    \n %s" % (__name__,err.message) return -1 else: return 0 def SendCOMMIT(self): """   """ try: self.db.query("COMMIT") except ProgrammingError,err: self.err = " %s:    \n %s" % (__name__,err.message) return -1 else: return 0 def SendROLLBACK(self): """   """ try: self.db.query("ROLLBACK") except ProgrammingError,err: self.err = " %s:     \n %s" % (__name__,err.message) return -1 else: return 0 def GetTupleResult(self): """       """ try: res = self.query_collector.getresult() except: res = [] self.query_collector = None return res def GetDictResult(self): """       """ try: res = self.query_collector.dictresult() except: res = {} self.query_collector = None return res def GetError(self): """      """ res = self.err self.err = '' return res def GetObjectStruct(self,name): try: return self.db.get_attnames(name) except Exception,err: self.err = " %s:     \n%s"%(__name__,err.message) return () 

आइए प्रस्तुत वर्ग के कुछ तरीकों का विश्लेषण करें। SendQueryReturn और SendQueryNoreturn तरीकों को सुविधा के लिए हाइलाइट किया गया है, हालांकि, सिद्धांत रूप में, आप एक चीज का उपयोग करने पर ध्यान केंद्रित कर सकते हैं। पहली विधि उन प्रश्नों के लिए है जो चयन परिणाम लौटाते हैं।

यह एक सफल क्वेरी के मामले में, पंक्तियों की संख्या देता है। क्वेरी परिणाम को वर्ग के query_collector विशेषता में संग्रहीत किया जाता है।

SendQueryNoreturn, क्रमशः, डेटासेट वापस न करने वाले प्रश्नों को निष्पादित करने के लिए डिज़ाइन किया गया है। यदि अनुरोध सफल होता है, तो विधि 0 वापस आ जाएगी।

एक त्रुटि के मामले में, दोनों विधियाँ -1 वापस आती हैं। त्रुटि विवरण GetError का उपयोग करके प्रोग्राम में वापस किया जा सकता है।

GetTupleResult और GetDictResult विधियाँ टुपल्स की सूची के रूप में या नामित अनुक्रमों की सूची के रूप में प्राप्त चयन का परिणाम लौटाती हैं । और एक अन्य विधि जिस पर आपको ध्यान देना चाहिए वह है GetObjectStruct । यह विधि "शब्दकोश नाम" - "डेटा प्रकार" जोड़े से युक्त एक शब्दकोश देती है।

क्वेरी स्तर

मैंने एक अलग मॉड्यूल में डेटाबेस प्रश्नों का चयन किया। उपयोग की जाने वाली कक्षाएं डेटाबेस प्रबंधन प्रणाली या डेटाबेस कनेक्शन लाइब्रेरी के प्रकार के बारे में कुछ भी नहीं जानती हैं। पीजी मॉड्यूल का उपयोग ऊपर वर्णित किया गया है, हालांकि कुछ और का उपयोग करने से आपको कुछ भी नहीं रोक रहा है। मुख्य शर्त यह है कि डेटाबेस कनेक्शन स्तर की कक्षाओं में समान तरीकों का सेट होना चाहिए।

 def set_connection(conn): global connection if conn == 'pg': import connection.pg_connection as connection ... 

Set_connection फ़ंक्शन डेटाबेस के कनेक्शन के प्रकार को निर्धारित करता है और कनेक्शन उपनाम के तहत संबंधित मॉड्यूल को आयात करता है।
अगला, एक या अधिक वर्ग छिपाए जा सकते हैं जो अनुरोध प्रसंस्करण तंत्र को छिपाते हैं:

 from query_constants import * class QueryLayout: def __init__(self,dbname,user,password,host='localhost',port=5432): global connection self.err_list = [] if connection: self.conn = connection.Connection(dbname,user,password,host,port) else: self.CONNECTED = False self.err_list = [] self.CONNECTED = self.SetConnection() def SetConnection(self): try: self.conn.Connect() except Exception,err: self.err_list.append(err.message) return False else: return True def CloseConnection(self): self.conn.Disconnect() def QueryNoreturn(self,query): """   ,    """ if self.conn.SendQueryNoreturn(query) == 0: return 1 else: self.err_list.append(self.conn.GetError()) return 0 def QueryReturn(self,query): """   ,   """ res = self.conn.SendQueryReturn(query) if res < 0: self.err_list.append(self.conn.GetError()) return res def GetDataTuple(self): return self.conn.GetTupleResult() def GetDataDict(self): return self.conn.GetDictResult() def GetErrors(self): res = self.err_list self.err_list = [] return res def GetObjectStruct(self,objname): return self.conn.GetObjectStruct(objname) class CustomQuery(QueryLayout): def __init__(self,dbname,user,password,host='localhost',port=5432): QueryLayout.__init__(self,dbname,user,password,host,port) def BEGIN(self): if self.conn.SendBEGIN() < 0: err_list = self.conn.GetErrors() err_list.insert(0,u" ") return False return True def COMMIT(self): if self.conn.SendCOMMIT() < 0: err_list = self.conn.GetErrors() err_list.insert(0,u" ") return False return True def ROLLBACK(self): if self.conn.SendROLLBACK() < 0: err_list = self.conn.GetErrors() err_list.insert(0,u" ") return False return True def CustomGet(self,query,mode='dict',warn=False): nRes = self.QueryReturn(query) if nRes > 0: if mode == 'tuple': res = self.GetDataTuple() else: res = self.GetDataDict() return {'res':len(res),'err':[],'inf':res} elif nRes == 0: if warn: return {'res':-1,'err':[u" "],'inf':[]} else: return {'res':0,'err':[],'inf':{}} else: err_list = self.GetErrors() err_list.insert(0,u"   ") return {'res':-1,'err':err_list,'inf':[]} def CustomSet(self,query): nRes = self.QueryNoreturn(query) if nRes == 1: return {'res':0,'err':[],'inf':[]} else: err_list = self.GetErrors() err_list.insert(0,u"   ") return {'res':-1,'err':err_list,'inf':[]} 

विधियों में, CustomGet और CustomSet क्वेरी निष्पादन और वापसी परिणामों की प्रक्रियाओं पर एक एकीकृत ऐड-ऑन हैं। शब्दकोश वापसी मूल्य के रूप में कार्य करता है। शब्दकोश का पहला तत्व क्वेरी का परिणाम है। दूसरा अपवादों की सूची है। तीसरा प्रश्न का परिणाम है। कस्टमगेट विधि, अतिरिक्त मापदंडों के रूप में, लौटाए गए डेटा और खाली चयन के प्रसंस्करण ध्वज का रूप लेती है (कुछ मामलों में, इसे त्रुटि के रूप में माना जा सकता है)।

प्रश्न और उनका निष्पादन

अब हम अपनी तालिका के लिए क्वेरी पैटर्न परिभाषित करते हैं

 ADD_NEW_POINT = "select * from dicts.insert_point('%s',%s)" DELETE_POINT = "select * from dicts.delete_point(%s)" EDIT_POINT = "select * from dicts.update_point(%s,'%s',%s)" GET_ALL_POINTS = "select * from dicts.get_all_points" 

आप प्रश्नों का स्पष्ट रूप से उपयोग कर सकते हैं, लेकिन मैं विचारों और संग्रहीत प्रक्रियाओं के साथ काम करना पसंद करता हूं।

अब आप उच्च स्तर पर स्वयं क्वेरी निष्पादन तंत्र की कल्पना कर सकते हैं:

 class QueryCollector(CustomQuery): def __init__(self,dbname,user,password,host='localhost',port=5432): CustomQuery.__init__(self,dbname,user,password,host,port) def AddNewPoint(self,sPointName,nHour): return self.CustomSet(ADD_NEW_POINT%(sPointName,nHour)) def DeletePoint(self,nIdPoint): return self.CustomSet(DELETE_POINT%nIdPoint) def EditPoint(self,nIdPoint,sPointName,nHour): return self.CustomSet(EDIT_POINT%(nIdPoint,sPointName,nHour)) def GetAllPoints(self): return self.CustomGet(GET_ALL_POINTS) 

डेटा मॉडल

मॉडल का उपयोग करने के लिए, हमें कुछ स्थिरांक को परिभाषित करना होगा।

 COLUMN_TYPES = {'int':lambda:int(),'bool':lambda:bool(),'text':lambda:unicode()} CAST_TYPES = {'int':lambda x:int(x),'bool':lambda x:bool(x),'text':lambda x:unicode(x,'utf-8')} POINTS = {'obj_name':'Point','struct':'dicts.get_all_points','select':'GetAllPoints','insert':'AddNewPoint','update':'EditPoint','delete':'DeletePoint'} CONST_NAMES = {'Points':POINTS} 

COLUMN_TYPES आधार विशेषता प्रकार को परिभाषित करता है। भविष्य के डेटा मॉडल के वर्ग का वर्णन करने के चरण में यह आवश्यक है। CAST_TYPES ऑब्जेक्ट बनाने के चरण में आवश्यक प्रकार के डेटा को डालने का एक प्रयास है।
POINTS शब्दकोश हमारी वस्तु का मेटाडेटा है। वर्ग नाम यहां संग्रहीत किया जाता है, साथ ही उन विधियों के नाम भी शामिल होते हैं जिन्हें ऑब्जेक्ट की संरचना का निर्धारण करते समय, सिलेक्ट, इंसर्ट, अपडेट मेथड्स आदि को निष्पादित करते हुए बुलाया जाएगा।

ऑब्जेक्ट बनाएँ

सबसे पहले, मैंने डेटाबेस से प्राप्त प्रत्येक प्रकार के ऑब्जेक्ट को एक अलग वर्ग के रूप में वर्णित किया, लेकिन जल्द ही एक अधिक सुरुचिपूर्ण समाधान आया - वर्ग कारखाने का उपयोग करके। हमारे उदाहरण में, दो प्रकार की वस्तुएं बनाई जाएंगी: एक कंटेनर ऑब्जेक्ट, जिसमें परमाणु वस्तुओं का संग्रह होगा, जिनमें से प्रत्येक आधार से प्राप्त निपटान का वर्णन करेगा।

 class ModelManager: def __init__(self,dbname,user,password,host='localhost',port=5432): self.query_collector = query_layout.QueryCollector(dbname,user,password,host,port) def BuildModel(self,name,**props): """ model builder NAME - the name of data struct, props - additional properties """ c_atts = self.GetMetaData(name) or {} struct = self.query_collector.GetObjectStruct(c_atts['struct']) or {} dctOptions = {} for i in struct.items(): dctOptions[i[0]] = m_const.COLUMN_TYPES.get(i[1])() for i in props.items(): dctOptions[i[0]] = i[1] return [struct,dctOptions] def GetMetaData(self,name): """ get meta data for loading struct """ return m_const.CONST_NAMES.get(name) def GetInlineMethods(self,name,**methods): """ get's methods from QueryCollector object""" c_atts = self.GetMetaData(name) dctMethods = {} if methods: dctMethods.update(methods) if c_atts: try: dctMethods['Update'] = getattr(self.query_collector,c_atts['update']) except: dctMethods['Update'] = lambda:Warning("This method is not implemented!") try: dctMethods['Delete'] = getattr(self.query_collector,c_atts['delete']) except: dctMethods['Delete'] = lambda:Warning("This method is not implemented!") return dctMethods def GetCollectMethods(self,name,**methods): """ get's methods from QueryCollector to Collection object """ c_atts = self.GetMetaData(name) dctMethods = {} if methods: dctMethods.update(methods) if c_atts: try: dctMethods['Insert'] = getattr(self.query_collector,c_atts['insert']) except: dctMethods['Insert'] = lambda:Warning("This method is not implemented!") try: dctMethods['Select'] = getattr(self.query_collector,c_atts['select']) except: dctMethods['Select'] = lambda:Warning("This method is not implemented!") return dctMethods def CreateClass(self,name,i_methods={},props={}): """ creates a new object """ c_atts = self.GetMetaData(name) print c_atts o_meth = self.GetInlineMethods(name,**i_methods) struct,o_prop = self.BuildModel(name,**props) obj = classobj(c_atts['obj_name'],(object,),o_meth) setattr(obj,'struct',struct) for i in o_prop.items(): setattr(obj,i[0],i[1]) return obj def InitObject(self,obj,**values): dct_keys = obj.__dict__.keys() new_obj = obj() for i in values.items(): if i[0] in dct_keys: try: new_obj.__dict__[i[0]] = m_const.CAST_TYPES[new_obj.struct[i[0]]](i[1]) except: new_obj.__dict__[i[0]] = None return new_obj def InitCollection(self,name,**props): o = self.CreateClass(name) coll_meth = self.GetCollectMethods(name) collection = classobj(name,(object,),coll_meth)() if props: collection.__dict__.update(props) setattr(collection,'items',[]) dctRes = collection.Select() if dctRes['res']>= 0: collection.items = [self.InitObject(o,**i) for i in dctRes['inf']] return collection 

ModelManager वर्ग प्रारंभ में अंतर्निहित ऑब्जेक्ट (BuildModel) की संरचना को परिभाषित करता है। यदि वांछित है, तो मॉडल विशेषताओं को अपने स्वयं के साथ पूरक किया जा सकता है। GetInlineMethods और GetCollectMethods विधियाँ मौजूदा डेटाबेस एक्सेस फ़ंक्शंस को भविष्य की वस्तुओं में बाँधती हैं। एटम ऑब्जेक्ट में अंतर्निहित अपडेट और डिलीट करने के तरीके होंगे, और कंटेनर ऑब्जेक्ट सम्मिलित और चयन विधियों का उपयोग करके अपने संग्रह को फिर से भरने और अपडेट करने में सक्षम होंगे। CreateClass विधि वर्ग बनाने के लिए जिम्मेदार है, जिसके उदाहरण हम बाद में बनाएंगे। यहां हम नए मॉड्यूल के क्लासोबज फ़ंक्शन का उपयोग करेंगे, जो हमें एक नया वर्ग लौटाएगा।

अब आप उपयोग किए गए डेटाबेस के प्रकार को निर्दिष्ट कर सकते हैं, ModelManager वर्ग का एक उदाहरण बना सकते हैं, और InitCollection विधि को कॉल कर सकते हैं, जो एक ऑब्जेक्ट को लौटाएगा जिसमें आइटम विशेषता में पॉइंट्स टेबल से वस्तुओं की सूची शामिल है।
सिद्धांत रूप में, कंटेनर वस्तुओं का उपयोग परमाणु वस्तुओं के रूप में भी किया जा सकता है। एक से कई रिश्तों के कार्यान्वयन में, माता-पिता की वस्तुएं उनके वंशजों के लिए कंटेनर के रूप में कार्य करेंगी।