[BACK]Return to ZSQLExtend.py CVS log [TXT] [DIR] Up to [Repository] / ZSQLExtend

Diff for /ZSQLExtend/ZSQLExtend.py between versions 1.91 and 1.92

version 1.91, 2006/09/16 12:34:50 version 1.92, 2006/09/16 15:17:24
Line 1 Line 1
   
 from OFS.Folder import Folder  from OFS.Folder import Folder
 from Acquisition import Implicit  from Acquisition import Implicit
 from Globals import DTMLFile,package_home,Persistent  from Globals import DTMLFile,package_home,Persistent
Line 17  import Shared.DC.ZRDB.DA Line 18  import Shared.DC.ZRDB.DA
 import zLOG  import zLOG
 import os.path  import os.path
 import os  import os
   import copy
   
 from OFS.SimpleItem import SimpleItem  from OFS.SimpleItem import SimpleItem
   
 def analyseIntSearch(word):  def analyseIntSearch(word):
Line 72  class ZSQLExtendFolder(Folder,Persistent Line 75  class ZSQLExtendFolder(Folder,Persistent
         return sql_quote(str)          return sql_quote(str)
           
           
     def importXMLFile(self,table,containerTagName,file,identify=None,RESPONSE=None):      def normalizeField(self,table,fieldname, newFieldName=None,mode="alter", RESPONSE=None):
           """normalize a field"""
           import unicodedata
           
           if not newFieldName:
               newFieldName=fieldname+"_normal"
               
           def normal(str):
               if str:
                   return unicodedata.normalize('NFKD', str.decode('utf-8')).encode('ASCII', 'ignore')
               else:
                   return ""
           if mode=="create": # create the field
               qstr="""alter table %s add %s %s"""
               self.ZSQLSimpleSearch(qstr%(table,newFieldName,'text'))
           
           qstr="select oid,%s from %s"%(fieldname,table)
           for result in self.ZSQLSimpleSearch(qstr):
               qstr="update %s set %s = %s where oid = %s"
   
               self.ZSQLSimpleSearch(qstr%(table,newFieldName,self.ZSQLQuote(normal(getattr(result,fieldname))),result.oid))
           
       def importAccessModell(self,configFileName,RESPONSE=None):
           """import tables from access
           @param configFileName: xml-configfile
           """
           from Ft.Xml import Parse
           fh=file(configFileName)
   
           doc=Parse(fh)
           
           x=doc.xpath("//pathToFolder/@path")
           
           
           if not (len(x)==1): # tag ist nich eineindeutig
               return False
           
           pathToFolder=x[0].value
           
           for db in doc.xpath("//db"):
               
               containers=db.xpath("./@container")
               identifiers=db.xpath("./@identify")
               
   
               if not (len(containers)==1):
                   return False
               else:
                   container=containers[0].value
               
               if not (len(identifiers)==1):
                   identifier=None
               else:
                   identifier=identifiers[0].value
               
               self.xsdToTable(container.lower(),container,modus="drop",filename=os.path.join(pathToFolder,container.lower()+".xsd"))
               self.importXMLFileAccess(container.lower(),container,filename=os.path.join(pathToFolder,container.lower()+".xml"),identify=identifier)
               
           return "<html><body>DONE</body></html>"
        
       def xsdToTable(self,table,elementNameForTable,modus="update", filename=None,data=None,RESPONSE=None):
           """reads an xsd file an creates the columns of a table out of its structure
           @param table: name of the table the xml shall be imported into
           @param elementNameForTable: must be a element of type complex type. the element of the sequence in the complex type
                                       define the columns of the table >table<
           @param data (optional): data to be imported
       
           @param filename (optional) or filename
           @param identify: (optional) field res. tag which identifies a entry uniquely for updating purposes.
           @param RESPONSE: (optional)
    
           """
           #from xml.dom.minidom import parseString,parse
           
           from Ft.Xml import Parse
           zLOG.LOG("import xsd",zLOG.INFO,"called")
           #fh=file("/tmp/fmpxml.xml")
           import bz2
           import base64
           
           
           ret=""
           if data:
             data=bz2.decompress(base64.decodestring(data))
           
             #zLOG.LOG("import xsd",zLOG.INFO,"received file")
             doc=Parse(data)
             #zLOG.LOG("import xsd",zLOG.INFO,"parsed file")
           
           elif filename:
             fh=file(filename)
             txt=fh.read()
             
             doc=Parse(txt)
             #zLOG.LOG("import xsd",zLOG.INFO,"parsed file")
           
           
           Nss={'xsd':'http://www.w3.org/2001/XMLSchema'}
           definingSequence=doc.xpath("""//xsd:element[@name='%s']/xsd:complexType/xsd:sequence/xsd:element/@name"""%elementNameForTable,explicitNss=Nss)
           
           fieldNames=[x.value for x in definingSequence]
           
           
           
           #check if table exists
           
           qstr="""select relname from pg_class where relname = '%s'"""%table
           if not(self.ZSQLSimpleSearch(qstr)) or (len (self.ZSQLSimpleSearch(qstr))<1): # if not the create the table
               columns=[]
               create=True    
           else:
               create=False
               
               zLOG.LOG("update xsd: fieldnames",zLOG.INFO,repr(fieldNames))                       
               qstr="""select attname from pg_attribute, pg_class where attrelid = pg_class.oid and relname = '%s' """
               columns=[x.attname for x in self.ZSQLSimpleSearch(qstr%table)]            
           
           
           if (modus=="drop") and (not create): #table shall be deleted, therefore it should exist (not create)
               print "drop"
               qstr="""DROP TABLE %s """
               self.ZSQLSimpleSearch(qstr%table)
               columns=[]
               create=True
           
           for fieldName in fieldNames:
               if type(fieldName) is UnicodeType:
                   fieldName=fieldName.encode('utf-8')
               zLOG.LOG("update xml: fieldname",zLOG.INFO,repr(fieldName))                     
               if fieldName.lower() not in columns:
                   
                   if create:# table does not exist therefore create with one column
                       qstr="""create table %s (%s %s)"""
                       create=False
                   else:# otherwise add the field
                       qstr="""alter table %s add %s %s"""
                   
                   self.ZSQLSimpleSearch(qstr%(table,fieldName,'text'))
                   zLOG.LOG("update xsd: fieldname add",zLOG.INFO,qstr%(table,fieldName,'text'))                       
      
   
       def importXMLFileAccess(self,table,container,data=None,identify=None,filename=None,RESPONSE=None):
           '''
           Import XML file in access format into the table
           @param table: name of the table the xml shall be imported into
           @param containerTagName: XML-Tag which describes a dataset
           @param data: data to be imported
           @param identify: (optional) field res. tag which identifies a entry uniquely for updating purposes.
           @param RESPONSE: (optional)
           '''
           from xml.dom.pulldom import parseString,parse
           
           zLOG.LOG("import xml",zLOG.INFO,"called")
           #fh=file("/tmp/fmpxml.xml")
           import bz2
           import base64
           
           ret=""
           if data:
             data=bz2.decompress(base64.decodestring(data))
           
             zLOG.LOG("import xml",zLOG.INFO,"received file")
             doc=parseString(data)
             zLOG.LOG("import xml",zLOG.INFO,"parsed file")
   
           elif filename:
             fh=file(filename)
             doc=parse(fh)
             zLOG.LOG("import xml",zLOG.INFO,"parsed file")
           while 1:
               node=doc.getEvent()
   
               if node is None:
                   break;
               else:
                   if node[1].nodeName.lower()==container.lower(): # make everything case insensitive
                       doc.expandNode(node[1])
                       
                       dataSet={}
                       for col in node[1].childNodes:
                           if col.nodeType is col.ELEMENT_NODE: 
                               data=col.nodeName
                               dataSet[data]=getTextFromNode(col)
   
                       update=False
                       
                       if identify:
   
                           field=dataSet[identify]
   
                           searchStr="""select %s from %s where %s = '%s'"""%(identify,table,identify,field)
                           zLOG.LOG("import xml",zLOG.INFO,searchStr)
                           search=self.ZSQLSimpleSearch(searchStr)
                           if search:
                               update=True
                       
                       if update:
                           tmp=[]
                           for fieldName in dataSet.keys():
                               tmp.append("""%s = %s"""%(fieldName,self.ZSQLQuote(dataSet[fieldName])))
                           setStr=",".join(tmp)
   
                           field=dataSet[identify]
                     
                           queryStr="""UPDATE %s SET %s WHERE %s = '%s' """%(table,setStr,identify,field)
                           zLOG.LOG("update xml",zLOG.INFO,queryStr)
                           self.ZSQLSimpleSearch(queryStr)
                           ret+="ud: %s \n"%field
                       else:
   
                          
                           fields=",".join(dataSet.keys())
                           values=",".join([""" %s """%self.ZSQLQuote(dataSet[x]) for x in dataSet.keys()])
                     
                           
                           queryStr="""INSERT INTO %s  (%s) VALUES (%s)"""%(table,fields,values)
                           self.ZSQLSimpleSearch(queryStr)
                           zLOG.LOG("update xml",zLOG.INFO,queryStr)
                           
                           
                           
             
           return ret
           
       
       def importXMLFile(self,table,data=None,identify=None,filename=None,RESPONSE=None):
         #TODO: finish importXMLFile          #TODO: finish importXMLFile
         '''          '''
         Import XML file into the table          Import XML file into the table
Line 414  class ZSQLExtendFolder(Folder,Persistent Line 642  class ZSQLExtendFolder(Folder,Persistent
         except:          except:
             return None              return None
                   
        
       def ZSQLSequentialSearch(self,_fieldlist,_searchTerm,storename=None,args=None,**argv):
           """get a list of tuples (fields,searchoptions,table) to search the searchTerm in, returns dictionary. """
           #print "do search with:",_fieldlist,_searchTerm,storename,args,argv
           ret={} 
           if args:
               argTmp=args
           else:
               argTmp=argv
   
           for field in _fieldlist:
   
               argTmp2=copy.deepcopy(argTmp)
               argTmp2[field[0]]=_searchTerm
               argTmp2['_op_'+field[0]]=field[1]
               argTmp2['_table']=field[2]
               
               ret[field[0]]=(self.ZSQLInlineSearch(storename=storename,args=argTmp2),field[3],field[4])
           
           return ret
     def ZSQLInlineSearch(self,storename=None,args=None,**argv):      def ZSQLInlineSearch(self,storename=None,args=None,**argv):
         """inlinesearch"""          """inlinesearch"""
                   
Removed from v.1.91  
changed lines
  Added in v.1.92

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>