source: lliurex-abies2pmb/trunk/fuentes/lliurex-abies2pmb.install/usr/share/lliurex-abies2pmb/abies2pmb.py @ 4285

Last change on this file since 4285 was 4285, checked in by Juanma, 2 years ago

Package version

  • Property svn:executable set to *
File size: 20.5 KB
Line 
1#!/usr/bin/python3
2import os
3import datetime
4import subprocess
5import sys
6import tempfile
7# -*- coding: utf-8 -*-
8class abies2Pmb():
9        def __init__(self):
10                self.dbg=0
11               
12                #Dict with relations between pmb and abies
13                self.pmb_abies={}
14                self.pmb_abies["empr_categ"]=["TiposLector"]
15                self.pmb_abies["docs_location"]=["Ubicaciones"]
16                self.pmb_abies["authors"]=["Autores"]
17                self.pmb_abies["exemplaires"]=["Ejemplares"]
18                self.pmb_abies["notices"]=["Fondos"]
19                self.pmb_abies["collections"]=["Series"]
20                self.pmb_abies["notices_langues"]=["Fondos_Idiomas"]
21                self.pmb_abies["publishers"]=["Editoriales"]
22                self.pmb_abies["groupe"]=["Cursos"]
23                self.pmb_abies["indexint"]=["CDUs"]
24                self.pmb_abies["notices_tmp"]=["Fondos_all"]
25                self.pmb_abies["docs_type"]=["TiposFondo"] 
26                self.pmb_abies["docs_statut"]=["TiposEjemplar"] 
27
28                #Dict with forced column data type
29                self.formatPmbColumns={}
30                self.formatPmbColumns['indexint']={1:'string'}
31                self.formatPmbColumns['indexint'].update({3:'string'})
32
33                #Dict with default values to column
34                self.defaultPmbValues={}
35                self.defaultPmbValues['docs_location']={5:'1'}
36                self.defaultPmbValues['indexint']={4:'1'}
37                self.defaultPmbValues['notices']={29:'"m"'}
38                self.defaultPmbValues['notices'].update({38:'1'})
39                self.defaultPmbValues['exemplaires']={6:'28'}
40                self.defaultPmbValues['exemplaires'].update({9:'10'})
41                self.defaultPmbValues['exemplaires'].update({14:'2'})
42                self.defaultPmbValues['exemplaires'].update({23:'1'})
43                self.defaultPmbValues['docs_type']={2:'15'}
44                self.defaultPmbValues['docs_type'].update({3:'15'})
45                self.defaultPmbValues['docs_type'].update({7:'1'})
46                self.defaultPmbValues['docs_statut']={6:'1'}
47                self.defaultPmbValues['docs_statut'].update({7:'1'})
48
49
50                #Blacklist pmb_abies tables.
51                self.blacklist=['notices_tmp']
52
53                #Dict with abies source fields for pmb
54                #Numbers are the indexes of the source data table
55                self.pmb_tables={}
56                self.pmb_tables["docs_location"]=[0,1,'','','','','','','','','','','','','','','','','','','','','','','']
57                self.pmb_tables["empr_categ"]=[0,1,'','','','']
58                self.pmb_tables["authors"]=[0,1,2,'','','','','','','','','','','','']
59                self.pmb_tables["publishers"]=[0,1,'','','','','','','','']
60                self.pmb_tables["groupe"]=[0,1,'','','','']
61                self.pmb_tables["exemplaires"]=[0,4,1,'',3,13,'',2,6,'','','','','','','','',9,'','','','','','','','','']
62                self.pmb_tables["collections"]=[0,1,'','','','','','']
63                self.pmb_tables["indexint"]=[0,1,'',1,'']
64                self.pmb_tables["notices_tmp"]=[0,1,2,3,4,5]
65                self.pmb_tables["notices"]=[0,1,14,15,16,13,'','',19,'',24,'',20,17,25,11,21,22,23,'','','','','','','',26,'','','','','','','','','','','','','',6,'','','','','','','','','','','','','']
66                self.pmb_tables["notices_langues"]=[0,'',1,'']
67                self.pmb_tables["docs_type"]=[0,1,'','','','','','']
68                self.pmb_tables["docs_statut"]=[0,1,'','','','','','','']
69                #dict with needed virtual tables
70                #Only load one column using a 'get', any other column must be charged with formatTables or formatFields
71                self.virtual_tables={}
72                self.virtual_tables["CDUs"]={}
73                self.virtual_tables["CDUs"].update({'index 0':''})
74                self.virtual_tables["CDUs"].update({'index 1':'get Fondos_CDUs.1'})
75                self.virtual_tables['Series']={}
76                self.virtual_tables['Series'].update({'index 0':''})
77                self.virtual_tables['Series'].update({'index 1':'get Fondos.24'})
78                self.virtual_tables['Fondos_all']={'index 0':'get Fondos.0'}
79                self.virtual_tables['Fondos_all'].update({'index 1':''})
80                self.virtual_tables['Fondos_all'].update({'index 2':''})
81                self.virtual_tables['Fondos_all'].update({'index 3':''})
82                self.virtual_tables['Fondos_all'].update({'index 4':''})
83                self.virtual_tables['Fondos_all'].update({'index 5':''})
84                self.virtual_tables['Fondos_Idiomas']={}
85                self.virtual_tables['Fondos_Idiomas']={'index 0':'get Fondos.0'}
86                self.virtual_tables['Fondos_Idiomas'].update({'index 1':''})
87
88                #Dict whith field transformations
89                self.formatFields={}
90                self.formatFields['TiposLector']={'index 0':'add index 0 7'}
91                self.formatFields['Autores']={'index 1':'value 100=70,value 110=71,value 120=72,value 700=70'}
92                self.formatFields['Ejemplares']={'index 13':'concat 13,14,15'}
93                self.formatFields['Ejemplares'].update({'index 9':'date %m/%d/%y %H:%M:%S %Y-%m-%d %H:%M:%S'})
94#               self.formatFields['Ejemplares'].update({'index 2':'from Fondos_all.3 on 2=3'})
95                self.formatFields['Ejemplares'].update({'index 2':'from Fondos_all.5 on 2=3'})
96                #Replace index 3 with the needed data... Recipes from the other side...
97                self.formatFields['Ejemplares'].update({'index 3':'from Fondos_all.4 on 1=1'})
98                self.formatFields['CDUs']={'index 0':'inc 1 1000'}
99                self.formatFields['Series']={'index 0':'inc 1 1000'}
100                self.formatFields['Fondos']={'index 1':'value 1="a",value 2="g",value 3="m",value4="j",value 5="k",value 6="a",value 7="l"'}
101                self.formatFields['Fondos'].update({'index 13':'from Autores.2 on 13=0'})
102                self.formatFields['Fondos'].update({'index 24':'from Series.0 on 24=1'})
103                self.formatFields['Fondos'].update({'index 26':'from Fondos_all.2 on 0=1'})
104                self.formatFields['Fondos_all']={'index 2':'from CDUs.0 on 0=1'}
105                self.formatFields['Fondos_all'].update({'index 3':'from Ejemplares.2 on 1=1'})
106                self.formatFields['Fondos_all'].update({'index 4':'from Fondos.1 on 1=0'})
107                self.formatFields['Fondos_all'].update({'index 5':'add index 3 100'})
108                self.formatFields['Fondos_Idiomas']={'index 1':'from Fondos.9 on 0=0'}
109                self.formatFields['TiposFondo']={'index 0':'value 1=1,value 2=12,else=+100'}
110                self.formatFields['TiposEjemplar']={'index 0':'add index 0 100'}
111
112                #Dict whith special columns
113                self.formatTables={}
114                self.formatTables['CDUs']={'index 1':'uniq'}
115                self.formatTables['Series']={'index 1':'uniq'}
116                self.formatTables['Fondos_all']={'index 1':'from Fondos_CDUs.1 on 0=0'}
117
118
119                #Dict with errors
120                self.error={}
121                #self.error['status']=True
122
123                #Array with process order (including virtual tables)
124#               self.executionOrder=['Ubicaciones','TiposLector','Autores','Editoriales','Cursos','Ejemplares','Series','CDUs','Fondos_all','Fondos','Fondos_Idiomas','TiposFondo']
125                self.executionOrder=['Ubicaciones','TiposLector','Autores','Editoriales','Cursos','Series','CDUs','TiposEjemplar','Fondos_all','Ejemplares','Fondos','Fondos_Idiomas','TiposFondo']
126                #Tmp variables
127                self.workDir='/tmp/.abiesToPmb/'
128                self.tableValuesDict={}
129                self.tmpInc=0
130
131                #Work files
132                self.mdb=''
133                self.sql=''
134                self.sqlFiles=[]
135        #def _init
136
137        def _debug(self,msg):
138                if self.dbg:
139                        print('Migrator: '+str(msg))
140        #def _debug
141
142        def _error(self,code,index=None):
143                #Error Codes
144                #10 -> Table not found
145                #11 -> Error ocurred while importing mdb file
146                #12 -> Error exporting mdb to csv
147                #13 -> Error generating sql file
148                #14 -> Error concatenating sql files
149                #15 -> No source table for virtual table
150                #16 -> Couldn't fetch data from table
151                self.error['status']=False
152                self.error['code']=code
153#               if index:
154#                       if index in self.error.keys():
155#                               self.error[index].append(e)
156#                       else:
157#                               self.error[index]=e
158#               else:
159#                       if 'ERR' in self.error.keys():
160#                               self.error['ERR'].append(e)
161#                       else:
162#                               self.error['ERR']=e
163        #def _error
164
165        ###
166        #Process array executionOrder
167        ###
168        def beginMigration(self,mdbFile,sqlFile):
169
170                self.error['status']=True
171                self.error['code']=""
172                self.mdb=mdbFile
173                self.sql=sqlFile
174                if self.exportMdb():
175                        self.sqlFiles=[]
176                        for abiesTable in self.executionOrder:
177                                self.tmpInc=0
178                                self._debug("Processing "+abiesTable)
179                                self._loadTable(abiesTable)
180                                if not self.error['status']:
181                                        break
182                                pmbTable=self._getTableEquivalence(abiesTable)
183                                if not self.error['status']:
184                                        break
185                                self._generateSql(pmbTable,abiesTable)
186                                if not self.error['status']:
187                                        break
188                        if self.error['status']:
189                                self._debug("Concatenating sql files in an unique file")
190                                self._concatFiles()
191                        else:
192                                self._debug("Errors ocurred")
193                                self._debug(self.error)
194                        self._debug("Files generated for tables "+str(self.executionOrder))
195                else:
196                        self._error(11)
197
198                self._debug("ErrorDict:")
199                self._debug(self.error)
200                return self.error
201        #def beginMigration
202
203        def exportMdb(self):
204                returnValue=None
205                self._debug(self.mdb)
206                if os.path.exists(self.mdb):
207                        try:
208                                cmdOut=subprocess.check_output(['mdb-tables',self.mdb],universal_newlines=True)
209                                if cmdOut:
210                                        self.workDir=tempfile.mkdtemp()+"/"
211                                        tables=cmdOut.strip("\n")
212                                        listTables=tables.split(' ')
213                                        for table in listTables:
214                                                if table!='':
215                                                        cmdOut=subprocess.check_output(['mdb-export','-H','-d|||',self.mdb,table],universal_newlines=True)
216                                                        if cmdOut:
217                                                                f=open (self.workDir+table+".csv",'w')
218                                                                f.writelines(cmdOut)
219                                                                f.close()
220                                        returnValue=True
221                        except Exception as e:
222                                self._error(12)
223                                returnValue=False
224                return returnValue
225        #def exportMdb
226
227        ###
228        #Generates the sql
229        #Input: pmb tableName
230        #Output: Array of sql sentences
231        ###
232        def _generateSql(self,destTable,abiesTable):
233                transformDict=self._checkTransformField(abiesTable)
234                origData=self.tableValuesDict[abiesTable]
235                sqlFile=self.workDir+destTable+".sql"
236                fileName=destTable+".sql"
237                try:
238                        if destTable not in self.blacklist:
239                                f=open (sqlFile,'w')
240                        for line in origData:
241                                pmbColumn=0
242                                strInsertValues=''
243                                for index in self.pmb_tables[destTable]:
244                                        if index!='':
245                                                if transformDict:
246                                                        if index in transformDict.keys():
247                                                                strTransform=transformDict[index]
248#                                                               self._debug("Transforming value "+str(line[index])+" index "+str(index)+" with "+strTransform)
249                                                                line[index]=eval(strTransform)
250                                                tmp=str(line[index]).strip("\n")
251                                                #Clean tmp field
252                                                tmp=tmp.replace('"',' ')
253                                                chkFormat=True
254                                                if (destTable in self.formatPmbColumns):
255                                                        if index in self.formatPmbColumns[destTable]:
256                                                                chkFormat=False
257                                                                if self.formatPmbColumns[destTable][index]=='string':
258                                                                        tmp=str(tmp)
259                                                                        tmp=tmp.lstrip(' ')
260                                                                        tmp=tmp.rstrip(' ')
261                                                                        tmp='"'+tmp+'"'
262                                                                elif self.formatPmbColumns[destTable][index]=='int':
263                                                                        tmp=int(tmp)
264
265                                                if chkFormat:
266                                                        try:
267                                                                int(tmp)
268                                                        except:
269                                                                tmp=tmp.lstrip(' ')
270                                                                tmp=tmp.rstrip(' ')
271                                                                tmp='"'+tmp+'"'
272                                                                pass
273                                        else:
274                                                if (destTable in self.defaultPmbValues):
275                                                        if pmbColumn in self.defaultPmbValues[destTable]:
276                                                                tmp=self.defaultPmbValues[destTable][pmbColumn]
277                                                        else:
278                                                                tmp='""'       
279                                                else:
280                                                        tmp='""'
281                                               
282                                        strInsertValues=strInsertValues+tmp+','
283                                        pmbColumn=pmbColumn+1
284                                strInsertValues=strInsertValues[:-1]
285                                if destTable not in self.blacklist:
286                                        f.write("Insert into "+destTable+" values ("+strInsertValues+");\n")
287                        if destTable not in self.blacklist:
288                                f.close()
289                                self.sqlFiles.append(sqlFile)
290                except Exception as e:
291                        self._error(13)
292
293        #def _generateSql
294
295        ###
296        #Concats all the generated files
297        ###
298        def _concatFiles(self):
299                self._debug("Generating "+self.sql)
300                self._debug("Files list:")
301                self._debug(self.sqlFiles)
302                try:
303                        f=open(self.sql,'w')
304                        f.write("DELETE from docs_location;\n")
305                        f.write("DELETE from indexint;\n")
306                        f.write("DELETE from docs_type where idtyp_doc=1 or idtyp_doc=12;\n")
307                        for sqlFile in self.sqlFiles:
308                                self._debug("Opening "+sqlFile)
309                                a=open(sqlFile,'r')
310                                aContent=a.readlines()
311                                a.close()
312                                f.writelines(aContent)
313                        f.close()
314                except Exception as e:
315                        self._error(14)
316                       
317        #def _concatFile
318
319
320        ###
321        #Loads a table from a file or a virtual table from a bunch of tables
322        #Input: Table name
323        ###
324        def _loadTable(self,tableName):
325                returnValue=False
326                self._debug("Opening "+tableName)
327                fileName=self.workDir+tableName+'.csv'
328                data=[]
329                if os.path.exists(fileName):
330                        try:
331                                f=open(fileName,'r')
332                                lines=f.readlines()
333                                f.close()
334                                for line in lines:
335                                        array=line.split('|||')
336                                        data.append(array)
337                                returnValue=True
338                        except Exception as e:
339                                self._error(10)
340                else: #Check in virtual dict
341                        if tableName in self.virtual_tables.keys():
342                                data=self._loadVirtualTable(tableName)
343                                returnValue=True
344                        else:
345                                self._error(10)
346
347                self.tableValuesDict[tableName]=data
348                if tableName in self.formatTables.keys():
349                        self.tableValuesDict[tableName]=self._checkTransformTables(tableName)
350                return (returnValue)
351        #def _loadTable
352
353        ###
354        #Loads a virtual table as described by virtual tables dict
355        #Input: Table name
356        #Output: Dataset (array of arrays with the virtual table)
357        ###
358        def _loadVirtualTable(self,tableName):
359                self._debug("Loading virtual table "+tableName)
360                data=[]
361                dataDict={}
362                if tableName in self.virtual_tables.keys():
363                        proceed=False
364                        for key,line in self.virtual_tables[tableName].items():
365#                               print (s)ourceData)
366#                               for key,line in sourceData.items():
367                                        if line.startswith('get'):
368                                                proceed=True
369                                                sourceIndex=key.split(' ')[1]
370                                                getFrom=line.split(' ')[1]
371                                                sourceIndex=getFrom.split('.')[1]
372                                                sourceTable=getFrom.split('.')[0]
373                                                dataDict[key]=self._funcGetValueFromTable(sourceTable,sourceIndex)
374                        if proceed:
375                                #Data is charged on the dataDict, time to populate data array
376                                maxLen=0
377                                for key in dataDict.keys():
378                                        columnLen=len(dataDict[key])
379                                        if columnLen>maxLen:
380                                                maxLen=columnLen
381                                index=0
382                                while index<maxLen:
383                                        dataLine=[]
384                                        for key in self.virtual_tables[tableName].keys():
385                                                arrayIndex=int(key.split(' ')[-1])
386                                                if key in dataDict.keys():
387                                                        dataLine.insert(arrayIndex,dataDict[key][index])
388                                                else:
389                                                        dataLine.insert(arrayIndex,'')
390                                        data.append(dataLine)
391                                        index=index+1
392                else:
393                        self._error(15)
394                return(data)
395
396        ###
397        #Finds the pmb table related with an abies table
398        #Input: Table name in abies
399        #Output: pmb table name
400        ###
401        def _getTableEquivalence(self,tableName):
402                pmbTable=None
403                for key in self.pmb_abies.keys():
404                        if tableName in self.pmb_abies[key]:
405                                pmbTable=key
406                                break
407                return pmbTable
408        #def _getTableEquivalence
409
410        ###
411        #Check if there's any transformation to apply to the fields of a table
412        #Input: Abies table name
413        #Output: Dict with field indexes as keys and transformations to apply as values
414        def     _checkTransformField(self,abiesTable):
415                transformDict={}
416                if abiesTable in self.formatFields.keys():
417                        transform=self.formatFields[abiesTable]
418                        self._debug("Transforming fields "+str(transform)+" in "+abiesTable)
419                        for key,line in transform.items():
420                                index=int(key.split(' ')[-1])
421                                if line.startswith('add'):
422                                        transformDict[index]=self._transformAdd(line,index)
423                                elif line.startswith('value'):
424                                        transformDict[index]=self._transformValue(line,index)
425                                elif line.startswith('concat'):
426                                        transformDict[index]=self._transformConcat(line,index)
427                                elif line.startswith('date'):
428                                        transformDict[index]=self._transformDate(line,index)
429                                elif line.startswith('inc'):
430                                        transformDict[index]=self._transformInc(line,index)
431                                elif line.startswith('get'):
432                                        transformDict[index]=self._transformGet(line,index)
433                                elif line.startswith('from'):
434                                        transformDict[index]=self._transformQuery(line,index,abiesTable)
435
436                self._debug("TransformDict: "+str(transformDict))
437                return transformDict
438        #def _checkTransformField
439
440        ###
441        #Transform routines, self-explaining
442        ###
443        def _transformAdd(self,line,index):
444                sourceIndex=line.split(' ')[2]
445                increment=line.split(' ')[-1]
446                returnValue='int(line['+sourceIndex+'])+'+increment
447                return(returnValue)
448
449        def _transformValue(self,line,index):
450                values=line.split(',')
451                tmpStr=''
452                elseValue=None
453                for value in values:
454                        relation=value.split('=')
455                        destValue=relation[-1]
456                        if not relation[0].startswith('else'):
457                                sourceValue=relation[0].split(' ')[-1]
458                                tmpStr=tmpStr+str(destValue)+' if line['+str(index)+']=="'+str(sourceValue)+'" else '
459                        else:
460                                elseValue='str(int(line['+str(index)+']) '+str(destValue)+')'
461                if not elseValue:
462                        elseValue=destValue
463                        try:
464                                int(destValue)
465                                returnValue='('+tmpStr+ '"'+str(elseValue)+'")'
466                        except:
467                                returnValue='('+tmpStr+ ''+str(elseValue)+')'
468                else:
469                        returnValue='('+tmpStr +str(elseValue)+')'
470
471                return(returnValue)
472
473        def _transformConcat(self,line,index):
474                concat=line.split(' ')[-1]
475                concatArray=concat.split(',')
476                tmpStr=''
477                for concatField in concatArray:
478                        tmpStr=tmpStr+'line['+str(concatField)+']+'
479                returnValue=tmpStr[:-1]
480                return(returnValue)
481
482        def _transformDate(self,line,index):
483                dates=line.split(' ')
484                sourceFormat=dates[1]+' '+dates[2]
485                destFormat=dates[3]+' '+dates[4]
486                returnValue='self._funcDateTransform(line['+str(index)+'],"'+sourceFormat+'","'+destFormat+'")'
487                return(returnValue)
488
489        def _funcDateTransform(self,date,origFormat,destFormat):
490                date=date.replace('"','')
491                destFormat=destFormat.replace('"','')
492                returnValue=(datetime.datetime.strptime(date, origFormat).strftime(destFormat))
493                return(returnValue)
494               
495        def _transformInc(self,line,index):
496                increment=line.split(' ')
497                inc=increment[1]
498                base=0
499                if len(increment)==3:
500                        base=int(increment[2])
501                if self.tmpInc<base:
502                        self.tmpInc=base
503                returnValue='self._funcIncrementField('+inc+')'
504                return(returnValue)
505        ###
506        #Some values need a special transformation that requires a helper function.
507        #Those helper functions are the _func...
508        ###
509        def _funcIncrementField(self,inc):
510                self.tmpInc=self.tmpInc+int(inc)
511                returnValue=self.tmpInc
512                return(returnValue)
513
514        def _transformGet(self,line,index):
515                getFrom=line.split(' ')[-1]
516                getFromTable=getFrom.split('.')[0]
517                getFromIndex=getFrom.split('.')[-1]
518                returnValue='self._funcGetValueFromTable('+getFromTable+','+getFromIndex+')'
519                return(returnValue)
520
521        def _funcGetValueFromTable(self,table,index):
522                fileName=self.workDir+table+'.csv'
523                data=[]
524                index=int(index)
525                if os.path.exists(fileName):
526                        try:
527                                f=open(fileName,'r')
528                                lines=f.readlines()
529                                f.close()
530                                for line in lines:
531                                        array=line.split('|||')
532                                        data.append(array[index])
533                        except Exception as e:
534                                self._error(16)
535                else:
536                        self._error(16)
537                return(data)
538
539        def _transformQuery(self,line,index,tableName):
540                self._debug("Join field "+line)
541                transformDict=[]
542                arrayLine=line.split(' ')
543                sourceTableField=arrayLine[1]
544                joinFromTo=arrayLine[-1]
545                sourceTable=sourceTableField.split('.')[0]
546                sourceField=int(sourceTableField.split('.')[1])
547                joinFrom=joinFromTo.split('=')[0]
548                joinTo=joinFromTo.split('=')[1]
549                returnValue='self._funcGetValueFromQuery("'+tableName+'","'+sourceTable+'",line['+str(joinFrom)+'],'+str(joinTo)+','+str(sourceField)+')'
550                return(returnValue)
551
552        def _funcGetValueFromQuery(self,abiesTable,sourceTable,valueFrom,fieldTo,reqFieldIndex):
553                returnValue=''
554                valueFrom=valueFrom.strip("\n")
555                if sourceTable not in self.tableValuesDict:
556                        self._loadTable(sourceTable)
557                for row in self.tableValuesDict[sourceTable]:
558                                #                       print ("Comparing "+str(valueFrom)+" with "+str(row[fieldTo]))
559                        if valueFrom==str(row[fieldTo]).strip("\n"):
560                                returnValue=row[reqFieldIndex]
561                                break
562                return returnValue
563        #Transform fields functions
564
565        ###
566        #Check if there's any Transform to apply to a whole table
567        #Input: abies table
568        #Output: Dataset with the table
569        ###
570        def _checkTransformTables(self,tableName):
571                transformDict={}
572                if tableName in self.formatTables.keys():
573                        transform=self.formatTables[tableName]
574                        for key,line in transform.items():
575                                index=int(key.split(' ')[-1])
576                                if line.startswith('uniq'):
577                                        transformDict=self._transformTableUniq(tableName,index)
578                                if line.startswith('from'):
579                                        transformDict=self._transformTableJoin(tableName,index,line)
580                return transformDict
581        #def _checkTransformTamble
582
583        ###
584        #Function helpers for table transformation. Self-explaining
585        ###
586        def _transformTableUniq(self,tableName,index):
587                self._debug("Uniq items from index "+str(index))
588                transformDict=[]
589                for item in self.tableValuesDict[tableName]:
590                        if item not in transformDict:
591                                transformDict.append(item)
592                return transformDict
593
594        def _transformTableJoin(self,tableName,index,line):
595                self._debug("Join "+line)
596                transformDict=[]
597                arrayLine=line.split(' ')
598                sourceTableField=arrayLine[1]
599                joinFromTo=arrayLine[-1]
600                sourceTable=sourceTableField.split('.')[0]
601                sourceField=int(sourceTableField.split('.')[1])
602                joinFrom=joinFromTo.split('=')[0]
603                joinTo=joinFromTo.split('=')[1]
604                if sourceTable not in self.tableValuesDict:
605                        self._loadTable(sourceTable)
606                #Generate a dict with joinTo as index and required field as value
607                tmpDict={}
608                tmpIndex=int(joinTo)
609                for row in self.tableValuesDict[sourceTable]:
610                        rowIndex=row[tmpIndex]
611                        rowValue=row[sourceField]
612                        tmpDict.update({rowIndex:rowValue})
613
614                #Walk through origin table and insert values from sourceTableDict
615                tmpIndex=int(joinFrom)
616                for row in self.tableValuesDict[tableName]:
617                        rowIndex=row[tmpIndex]
618                        if rowIndex in tmpDict:
619                                row.insert(tmpIndex,tmpDict[rowIndex])
620                        else:
621                                row.insert(tmpIndex,'')
622                        transformDict.append(row)
623                return transformDict
624        #Table transformation function helpers
625
626### MAIN PROGRAM ###
627
628migration=abies2Pmb()
629result=migration.beginMigration(sys.argv[1],sys.argv[2])
630print(result)
Note: See TracBrowser for help on using the repository browser.