--- ZSQLExtend/ZSQLExtend.py	2005/10/10 15:34:50	1.64
+++ ZSQLExtend/ZSQLExtend.py	2006/03/28 19:54:41	1.79
@@ -17,8 +17,17 @@ import Shared.DC.ZRDB.DA
 import zLOG
 import os.path
 import os
+from OFS.SimpleItem import SimpleItem
 
+def getTextFromNode(nodename):
+    nodelist=nodename.childNodes
+    rc = ""
+    for node in nodelist:
+        if node.nodeType == node.TEXT_NODE:
+           rc = rc + node.data
+    return rc
 
+    
 def analyseIntSearch(word):
     #analyse integer searches
 
@@ -42,17 +51,157 @@ def sql_quote(v):
     quote_dict = {"\'": "''", "\\": "\\\\"}
     for dkey in quote_dict.keys():
         if string.find(v, dkey) >= 0:
-            v=join(split(v,dkey),quote_dict[dkey])
+            v=string.join(string.split(v,dkey),quote_dict[dkey])
     return "'%s'" % v
 
 def showSQLConnectionIDs(self):
     return SQLConnectionIDs(self)
 
+class ZSQLIndex(SimpleItem):
+    """index"""
+    meta_type="ZSQLIndex"
+    
+    def __init__(self,index,id,table=''):
+        self.index=[x for x in index]
+        self.id=id
+        self.table=table
+        
+    def setIndex(self,index):
+        self.index=[x for x in index]
+        
+    def getIndex(self):
+        return self.index
+
 class ZSQLExtendFolder(Folder,Persistent, Implicit):
     """Folder"""
     meta_type="ZSQLExtendFolder"
+    
+    def ZSQLQuote(self,str):
+        """quote str for sql"""
+        return sql_quote(str)
+    
+
+    
+    def importXMLFile(self,table,data,identify=None,RESPONSE=None):
+        #TODO: finish importXMLFile
+        '''
+        Import XML file 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
+        
+      
+        #fh=file("/tmp/fmpxml.xml")
+        import bz2
+        import base64
+        
+        ret=""
+        data=bz2.decompress(base64.decodestring(data))
+        #data=fh.read()
+
+        doc=parseString(data)
+        while 1:
+            node=doc.getEvent()
+            
+            if node is None:
+                break;
+            else:
+                if node[1].nodeName=='ROW':
+                    doc.expandNode(node[1])
+                    cols=node[1].getElementsByTagName('COL')
+                    dataSet=[]
+                    for col in cols:
+                        data=col.getElementsByTagName('DATA')
+                        dataSet.append(getTextFromNode(data[0]))
+                    update=False
+                    if identify:
+
+                        nr=fieldNames.index(identify)
+                        field=dataSet[nr]
+
+                        searchStr="""select %s from %s where %s = '%s'"""%(identify,table,identify,field)
+                        search=self.ZSQLSimpleSearch(searchStr)
+                        if search:
+                            update=True
+                    
+                    if update:
+                        tmp=[]
+                        for fieldName in fieldNames:
+                            tmp.append("""%s = %s"""%(fieldName,self.ZSQLQuote(dataSet[fieldNames.index(fieldName)])))
+                        setStr=",".join(tmp)
+                        nr=fieldNames.index(identify)
+                        field=dataSet[nr]
+                  
+                        queryStr="""UPDATE %s SET %s WHERE %s = '%s' """%(table,setStr,identify,field)
+                        self.ZSQLSimpleSearch(queryStr)
+                        ret+="ud: %s \n"%field
+                    else:
 
+                       
+                        fields=",".join(fieldNames)
+                        values=",".join([""" %s """%self.ZSQLQuote(x) for x in dataSet])
+                  
+                        
+                        queryStr="""INSERT INTO %s  (%s) VALUES (%s)"""%(table,fields,values)
+                        self.ZSQLSimpleSearch(queryStr)
+                        ret+="ad: %s \n"%field
+                        
+                elif node[1].nodeName=="METADATA":
+                    fieldNames=[]
+                    doc.expandNode(node[1])
+                
+                    names=node[1].getElementsByTagName('FIELD')
 
+                    for name in names:
+                        fieldNames.append(name.getAttribute('NAME'))
+
+                    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)]
+                 
+                    for fieldName in fieldNames:
+                        if fieldName not in columns:
+                            qstr="""alter table %s add %s %s"""
+                            self.ZSQLSimpleSearch(qstr%(table,fieldName,'text'))
+                  
+                #fn=node[1].getAttribute("xml:id")
+                #nf=file("xtf/"+fn+".xtf",'w')
+                #nf.write("""<texts xmlns="http://emegir.info/xtf" xmlns:lem="http://emegir.info/lemma" >"""+node[1].toxml()+"</texts>")
+                #print "wrote: %s"%fn
+        return ret
+             
+    def generateIndex(self,field,index_name,table,RESPONSE=None):
+        """erzeuge index aus feld"""
+        index={}
+        founds=self.ZSQLSimpleSearch("""SELECT %s,oid FROM %s LIMIT 2000"""%(field,table))
+
+        for found in founds:
+            tmp=getattr(found,field,None)
+            if tmp:
+                strings=tmp.split(" ")
+                for string in strings:
+                    if index.get(string):
+                        index[string].append(found.oid)
+                    else:
+                        index[string]=[found.oid]
+                    RESPONSE.write(string+"\n")
+            
+        if not hasattr(self,index_name):
+            obj=ZSQLIndex(index,index_name,table)
+            self._setObject(index_name,obj)
+                    
+        self._getOb(index_name).setIndex(index)
+        
+    def getIndex(self,index_name):
+        """getIndex"""
+        founds=self.ZopeFind(self,obj_ids=[index_name])
+        
+        return founds[0][1].getIndex()
+    
+            
     def testneu(self):
         """test"""
         relStatement="""period like '%s%%'"""
@@ -64,6 +213,7 @@ class ZSQLExtendFolder(Folder,Persistent
     def URLquote(self,txt):
         """urlquote"""
         return urllib.quote(txt)
+    
     def searchRel(self,relStatement,statement,wherePart,classes):
         """suche relative haufigkeiten"""
         ret={}
@@ -95,14 +245,22 @@ class ZSQLExtendFolder(Folder,Persistent
             return ""
 
     def getLabel(self):
-        """getLabe"""
+        """getLabel"""
         try:
             return self.label
         except:
             return ""
+ 
+    def getTitle(self):
+        """getTitle"""
+        try:
+            return self.title
+        except:
+            return ""
+
 
     def getDescription(self):
-        """getLabe"""
+        """getDescription"""
         try:
             return self.description
         except:
@@ -131,6 +289,12 @@ class ZSQLExtendFolder(Folder,Persistent
     def formatAscii(self,str,url=None):
         """ersetze ascii umbrueche durch <br>"""
         #url=None
+        
+        if not str:
+            return ""
+        
+        str=str.rstrip().lstrip()
+        
         if url and str:
             
             retStr=""
@@ -163,22 +327,22 @@ class ZSQLExtendFolder(Folder,Persistent
             return ""
 
     def actualPath(self,url=None):
-	"""path"""
+        """path"""
 
         if self.REQUEST['HTTP_X_FORWARDED_SERVER']=='':
             host=self.REQUEST['HTTP_HOST']
         else:
             host=self.REQUEST['HTTP_X_FORWARDED_SERVER']
-	if not url:
-		return "http://"+host+self.REQUEST['PATH_TRANSLATED']
-    	else:
-		temp=self.REQUEST[url].split("/")
-		temp[2]=host
-		return string.join(temp,"/")
+        if not url:
+                return "http://"+host+self.REQUEST['PATH_TRANSLATED']
+        else:
+                temp=self.REQUEST[url].split("/")
+                temp[2]=host
+                return string.join(temp,"/")
 
     def getRequest(self):
-	"""request"""
-	return self.REQUEST
+        """request"""
+        return self.REQUEST
 
     def lowerEnd(self,path):
         """oinly for demo"""
@@ -195,12 +359,12 @@ class ZSQLExtendFolder(Folder,Persistent
 
     def ZSQLsearchOptions(self,fieldname=""):
         """return HTML Fragment with search options"""
-	
+        
         ret="""<select name="-op_%s">
-	<option value="bw">begins with</option>          	<!-- begins with / beginnt mit, "Wort*" -->
-	<option value="ew">ends with</option>
-   	<option value="ct" selected>contains</option>          		<!-- contains / enthaellt, "Wort" -->
-    <option value="eq">equals</option>          		<!-- equals / ist, =Wort -->
+        <option value="bw">begins with</option>                 <!-- begins with / beginnt mit, "Wort*" -->
+        <option value="ew">ends with</option>
+        <option value="ct" selected>contains</option>                   <!-- contains / enthaellt, "Wort" -->
+    <option value="eq">equals</option>                          <!-- equals / ist, =Wort -->
 </select>"""%fieldname
         return ret
 
@@ -231,7 +395,7 @@ class ZSQLExtendFolder(Folder,Persistent
         return ret
 
 
-    def ZSQLOptionsFromCRList(self,fieldname,listField, multiple='',start=None,startValue=None,size=None):
+    def ZSQLOptionsFromCRList(self,fieldname,listField, multiple='',start=None,startValue=None,size=None,selected=None):
         """generate select oprions form a cr seperated list"""
         fields=listField.split("\n")
         if size:
@@ -242,14 +406,17 @@ class ZSQLExtendFolder(Folder,Persistent
             ret="""<select name="%s" %s >
             """%(fieldname,multiple)
         if start:
-	    if start==' ':
-		start=''
+            if start==' ':
+                start=''
                 if not startValue:
                     startValue=start
                     
             ret+="""<option value="%s" >%s</option>"""%(startValue,start)
         for field in fields:
-            ret+="""<option value="%s">%s</option>"""%(field.encode('utf-8'),field.encode('utf-8'))
+            if selected and (field in selected.split("\n")):
+                 ret+="""<option selected value="%s">%s</option>"""%(field.encode('utf-8'),field.encode('utf-8'))
+            else:
+                 ret+="""<option value="%s">%s</option>"""%(field.encode('utf-8'),field.encode('utf-8'))
         ret+="""</select>"""
         return ret
 
@@ -277,11 +444,12 @@ class ZSQLExtendFolder(Folder,Persistent
             ret="""<select name="%s" %s %s>
             """%(fieldname,multiple,additionalSelect)
         if start:
-	    if start==' ':
-		start=''
-                if not startValue:
+            if start==' ':
+                        start=''
+            
+            if not startValue:
                     startValue=start
-                    
+                            
             ret+="""<option value="%s" >%s</option>"""%(startValue,start)
         for result in results:
             field=getattr(result,fieldName)
@@ -303,6 +471,7 @@ class ZSQLExtendFolder(Folder,Persistent
         qs=[]
         if storename:
             """store"""
+            storename=storename
         else:
             storename="foundCount"
             
@@ -345,44 +514,66 @@ class ZSQLExtendFolder(Folder,Persistent
         """inlinesearch"""
         qs=[]
         
-    
-        
         #print "INLINE:",query
         return self.ZSQLSimpleSearch(query)
     
-    
-    def ZSQLSimpleSearch(self,query=None,max_rows=1000000):
+
+    def ZSQLResetConnection(self):
+        """reset the connectione"""
+        try:
+            self.getConnectionObj().manage_close_connection()
+        except:
+            zLOG.LOG("ZSQLResetConnection",zLOG.ERROR, '%s %s'%sys.exc_info()[:2])
+        try:
+            self.getConnectionObj().manage_open_connection()
+        except:
+            zLOG.LOG("ZSQLResetConnection",zLOG.ERROR, '%s %s'%sys.exc_info()[:2])
+
+    def ZSQLSimpleSearch(self,query=None,max_rows=1000000,debug=None):
         """simple search"""
 
+
         if not query:
             query=self.query
-        
+	
+        if debug:
+                print "DEBUG: ZSQLSimpleSearch:", query
         if (hasattr(self,"_v_searchSQL") and (self._v_searchSQL == None)) or (not hasattr(self,"_v_searchSQL")):
-            self._v_searchSQL=Shared.DC.ZRDB.DA.DA("_v_searchSQL","_v_searchSQL",self.connection_id,"var","<dtml-var var>")
+            
+            self._v_searchSQL=Shared.DC.ZRDB.DA.DA("_v_searchSQL","_v_searchSQL",self.getConnectionObj().getId(),"var","<dtml-var var>")
             
             self._v_searchSQL.max_rows_=max_rows
             try:
-                
                 return self._v_searchSQL.__call__(var=query)
             except :
+
                 if sys.exc_info()[0]=="Database Error":
                     try:
-                        getattr(self,self.connection_id).manage_open_connection()
-                    except: pass
+                        self.getConnectionObj().manage_open_connection()
+                    except:
+                        zLOG.LOG("ZSQLSimpleSearch",zLOG.ERROR, '%s %s'%sys.exc_info()[:2])
         else:
             try:
+
                 self._v_searchSQL.max_rows_=max_rows
                 
                 return self._v_searchSQL.__call__(var=query)
             except :
+
                 if sys.exc_info()[0]=="Database Error":
                     try:
-                        getattr(self,self.connection_id).manage_open_connection()
-                    except: pass
+                        self.getConnectionObj().manage_open_connection()
+                    except:
+                        zLOG.LOG("ZSQLSimpleSearch",zLOG.ERROR, '%s %s'%sys.exc_info()[:2])
+
+    def getConnectionObj(self):
+        if hasattr(self,'connection_id'):
+            return getattr(self,self.connection_id)
+       
                     
     def ZSQLSimpleSearch2(self,query=None):
         """ returrn SQLSearch"""
-        #print "hi",query
+       
         if not query:
             query=self.query
         if getattr(self,'_v_search',None):
@@ -406,20 +597,36 @@ class ZSQLExtendFolder(Folder,Persistent
     
         
         
-    def ZSQLAdd(self):
+    def ZSQLAdd(self,format=None,RESPONSE=None,**argv):
         """Neuer Eintrag"""
-        qs=self.REQUEST['QUERY_STRING']
+            
+        qs_temp=[]
+    
+        for a in self.REQUEST.form.keys():
+            qs_temp.append(a+"="+urllib.quote(str(self.REQUEST.form[a])))
+
+        qs=string.join(qs_temp,",")
+        
+        for field in argv.keys():
+                   if field[0]=="_":
+                       fieldTmp="-"+field[1:]
+                   else:
+                       fieldTmp=field
+                       
+                   qs+=",%s=%s"%(fieldTmp,argv[field])
+        
+        
         addList={}
-        for q in qs.split("&"):
+        for q in qs.split(","):
             name=re.sub("r'+'"," ",q.split("=")[0].lower())
             value=q.split("=")[1]
-	    value=re.sub(r'\+'," ",value)
-	    value=urllib.unquote(value)	
+            value=re.sub(r'\+'," ",value)
+            value=urllib.unquote(value)	
             if name=="-table":
                 table=urllib.unquote(value)
             elif name=="-format":
                 format=urllib.unquote(value)
-            elif (not name[0]=="-") and (not len(value)==0):
+            elif (not (name[0]=="-" or name[0]=="_")) and (not len(value)==0):
                 addList[urllib.unquote(name)]=urllib.unquote(value)
 
         keyList=[]
@@ -432,38 +639,45 @@ class ZSQLExtendFolder(Folder,Persistent
         valueString=string.join(valueList,",")
         
         queryString="INSERT INTO %s (%s) VALUES (%s)"%(table,keyString,valueString)
+
         self.ZSQLSimpleSearch(queryString)
-        return self.REQUEST.RESPONSE.redirect(format)
         
-    def ZSQLChange(self,format=None,RESPONSE=None,**argv):
+        if RESPONSE and format:
+            return RESPONSE.redirect(format)
+        else:
+            return True
+        
+    def ZSQLChange(self,format=None,RESPONSE=None,USE_FORM=None,**argv):
         """change entries"""
         #qs=self.REQUEST['QUERY_STRING']
         # very bad hack
         
         qs_temp=[]
-    
-        for a in self.REQUEST.form.keys():
-            qs_temp.append(a+"="+urllib.quote(str(self.REQUEST.form[a])))
+        if USE_FORM or RESPONSE:
+            for a in self.REQUEST.form.keys():
+                qs_temp.append(a+"="+urllib.quote(str(self.REQUEST.form[a])))
 
-        qs=string.join(qs_temp,",")
+        
         
         for field in argv.keys():
+                
                    if field[0]=="_":
                        fieldTmp="-"+field[1:]
                    else:
                        fieldTmp=field
                        
-                   qs+=",%s=%s"%(fieldTmp,argv[field])
+                   qs_temp.append("%s=%s"%(fieldTmp,argv[field]))
         
         
         changeList=[]
-        for q in qs.split(","):
-            print q
+        
+        for q in qs_temp:
+            
             name=urllib.unquote(re.sub("r'+'"," ",q.split("=")[0].lower()))
             value="=".join(q.split("=")[1:])
             value=re.sub(r'\+'," ",value)
             value=urllib.unquote(value)
-            
+        
             if name=="-table":
                     table=urllib.unquote(value)
             elif name=="-identify":
@@ -471,11 +685,14 @@ class ZSQLExtendFolder(Folder,Persistent
                 identify=identify.split("=")[0]+"="+sql_quote(identify.split("=")[1])
             elif name=="-format":
                 format=urllib.unquote(value)
-            elif (not name[0]=="-") and (not len(value)==0):
+            elif (not (name[0]=="-" or name[0]=="_")) and (not len(value)==0):
+
                 changeList.append("\""+name+"\"="+sql_quote(urllib.unquote(value)))
                 
         changeString=string.join(changeList,",")
+
         queryString="UPDATE %s SET %s WHERE %s"%(table,changeString,identify)
+
         self.ZSQLSimpleSearch(queryString)
         
         
@@ -485,6 +702,19 @@ class ZSQLExtendFolder(Folder,Persistent
             return True
    
 
+    def ZSQLFindIndexed(self,qs="",select="oid,*",storename=None,indexedFields=['data_line'],restrictField='id_text',**argv):
+        """find2"""
+        
+        for index in self.ZopeFind(self,obj_ids=indexedFields):
+            txt=argv.get(index[0],None)
+            if txt:
+                oids=index[1].getIndex()[txt]
+                
+        search1= self.ZSQLFind(qs=qs,select=select,storename=storename,tableExt=tableList[1],restrictField=restrictField,NoQuery='yes',NoLimit='yes',**argv)
+     
+        search2 = self.ZSQLFind(tableExt=tableList[0],qs=qs,select=select,storename=storename,restrictConnect=(tableList[0]+"."+restrictField,search1),**argv)
+        return search2
+    
     def ZSQLFind2(self,qs="",select="oid,*",storename=None,tableList=['cdli_translit','cdli_cat'],restrictField='id_text',**argv):
         """find2"""
 
@@ -496,9 +726,10 @@ class ZSQLExtendFolder(Folder,Persistent
       
     
     def ZSQLFind(self,qs="",select="oid,*",storename=None,tableExt=None,NoQuery=None,NoLimit=None,restrictField=None,restrictConnect=None,filter=None,**argv):
-        """Find"""
+        """search in database"""
 
         def delEmpty(list):
+            """"loesche leere elemente aus der liste"""
             ret=[]
             for x in list:
                 splitted=x.split("=")
@@ -506,22 +737,18 @@ class ZSQLExtendFolder(Folder,Persistent
                     ret.append(x)
             return ret
 
-
-
-        #self.REQUEST.SESSION['come_from_search']="no" # zuruecksetzen
         if qs=="":
-           
+           #kein querystring ubergeben 
            if self.REQUEST['QUERY_STRING']:
                qs=self.REQUEST['QUERY_STRING']
 
-               
                qs=string.join(qs.split("&"),",")
 
                for field in argv.keys():
                    if field[0]=="_":
                        fieldTmp="-"+field[1:]
                    else:
-                       fieldTmp=field
+                       fieldTmp=urllib.unqoute(field)
                        
                    qs+=",%s=%s"%(fieldTmp,argv[field])
                    
@@ -546,7 +773,7 @@ class ZSQLExtendFolder(Folder,Persistent
             
         
         
-        qs=re.sub("\\+"," ",qs)# Austauschen da Leerzeichen bei http-get durch + ersetzt wird, generell sollte alles auf post umgeschrieben werden. vom search formular.
+        qs=re.sub("\\+"," ",qs)#TODO: Austauschen da Leerzeichen bei http-get durch + ersetzt wird, generell sollte alles auf post umgeschrieben werden. vom search formular.
 
         qs=string.join(delEmpty(qs.split(",")),",")
 
@@ -674,6 +901,8 @@ class ZSQLExtendFolder(Folder,Persistent
         """analysieren den QueryString"""
         
         
+        #setzte generische werte
+        
         lop="AND" # standardsuche mit and
         max="ALL" #standard alle auswaehlen
         maxstr=""
@@ -689,21 +918,22 @@ class ZSQLExtendFolder(Folder,Persistent
         limit=0
         searchFields={}
         searchFieldsOnly={}
+        queryTemplate=[]
+        
         if not select:
             select="oid,*"
-        #print "Q",nostore,qs
-        #check for op 
-
 
+        #check for op 
+        splitted=qs.split(",")
 
-        
-	splitted=qs.split(",")
         if tableExt:
             table=tableExt
 
         if restrictField:
                     select=restrictField
-            
+        
+        
+        #erster durchgang suche operatoren    
         for q in splitted:
                 
                 name=re.sub("r'+'"," ",q.split("=")[0].lower())
@@ -734,25 +964,21 @@ class ZSQLExtendFolder(Folder,Persistent
                         sortAllFields=value
                     else:
                         sortfields[field]=value
-                    
-                    #print "HI",op,field
-	#print opfieldsa
-        #now analyse the querystring
-       
+                        
+        #zweiter durchgang analysiere felder
         for q in qs.split(","):
        
             
-            #try:
-
+          
             name=re.sub("r'+'"," ",q.split("=")[0].lower())
             try:
                 value=urllib.unquote(q.split("=",1)[1])
             except:
                 value=""
             
-            #value=sql_quote(value)
-            
-
+            punktsplit=name.split(".")   #sonderfall feld mit punkten(tabelle.suchFeld.ausgewaehltesFeld,feldinoriginal), d.h. suche in anderer tabelle:                      
+         
+            #analysiere alle anderen faelle
             if name==iCT+"lop":
                 lop=value
             elif name==iCT+"table":
@@ -793,7 +1019,53 @@ class ZSQLExtendFolder(Folder,Persistent
                 op=value
 
 
+            
+            elif (not name[0]==iCT) and len(punktsplit)==4:
+                if opfields.has_key(name):
+                    op=opfields[name]
+                else:
+                    op="ct"
+                namealt=name
+                name="LOWER("+punktsplit[1]+")" 
+
+                if op=="ct":
+                    tmp=(name+" LIKE "+sql_quote("%"+value+"%"))
+                elif op=="gt":
+                    tmp=(name+">"+sql_quote(value))
+                elif op=="lt":
+                    tmp=(name+"<"+sql_quote(value))
+                elif op=="eq":
+                    tmp=(name+"="+sql_quote(value))
+                elif op=="bw":
+                    tmp=(name+" LIKE "+sql_quote(value+"%"))
+                elif op=="ew":
+                    tmp=(name+" LIKE "+sql_quote("%"+value))
+                elif op=="all":
+                    tmps=[]
+                    for word in value.split(" "):
+                        tmps.append(name+" LIKE "+sql_quote("%"+word+"%"))
+                        
+                    tmp=string.join(tmps,' AND ')
+
+                elif op=="numerical":
+                    term=analyseIntSearch(value)
+                    tmp=(name+" "+term)
+                elif op=="grep":
+                    tmp=(name+" ~* "+sql_quote(value))
+                elif op=="one":
+                    tmps=[]
+                    for word in value.split(" "):
+                        tmps.append(name+" LIKE "+sql_quote("%"+word+"%"))
+                        
+                    tmp=string.join(tmps,' OR ')
+
+                op="all"
+
 
+                searchTmp="""%s in (select %s from %s where %s)"""%(punktsplit[3],punktsplit[2],punktsplit[0],tmp)
+
+                queryTemplate.append(searchTmp)
+                
             elif (not name[0]==iCT) and (not len(value)==0):
 
 		#print "OP",op,name
@@ -848,6 +1120,7 @@ class ZSQLExtendFolder(Folder,Persistent
 
 
         whereList=["("+searchFields[x]+")" for x in searchFields.keys()]
+        whereList+=queryTemplate
         
         if len(whereList)>0:
             if filter:
@@ -871,13 +1144,14 @@ class ZSQLExtendFolder(Folder,Persistent
         #print "QE",table
         #print (select,table,where,sort,maxstr,skip)
         query="SELECT %s FROM %s %s %s %s %s"%(select,table,where,sort,maxstr,skip)
-        
+
         if not nostore=="yes":
             
             self.REQUEST.SESSION['qs']=opfields
         #print "IAMHERE again:", query
 
         if storename and (not NoQuery):
+
             query2="SELECT count(*) FROM %s %s"%(table,where)
             
             #print "QUERYSTRING:",self.REQUEST.SESSION[storename]['queryString2']
@@ -916,6 +1190,7 @@ class ZSQLExtendFolder(Folder,Persistent
             self.REQUEST.SESSION[storename]['searchFields']=searchFields
             self.REQUEST.SESSION[storename]['searchFieldsOnly']=searchFieldsOnly
 
+        
         if not NoQuery:
 
             return self.ZSQLQuery(query)
@@ -935,37 +1210,34 @@ class ZSQLExtendFolder(Folder,Persistent
         else:
             return value
         
-    def ZSQLQuery(self,query):
+    def ZSQLQuery(self,query,debug=None):
         """query"""
-
+        if debug:
+            zLOG.LOG("ZSQLQuery", zLOG.INFO, query)
+            
         return self.ZSQLSimpleSearch(query)
 
     
     def ZSQLSearch(self):
         """To be done"""
-        rq=self.REQUEST['QUERY_STRING']
-
-        querys=rq.split("&")
-        
-        
+           
         formatfile=self.REQUEST['URL1'] #generisch redirect zur gleichen url
+      
+        #zerlege querystring in key value paare
+        #TODO: check if this is really necessary, use argv**
         
-        for querytemp in querys:
+        rq=self.REQUEST['QUERY_STRING']
+        querys=rq.split("&")
+        for querytemp in querys: #zerg
             query=querytemp.split("=")
             
-            
-
-            
             try:
                 if query[0].lower()=="-format":
                     formatfile=query[1]
             except:
-                """nothing"""
+                pass
 
-                
-        #print formatfile
-        
-        
+        #sichern
         self.REQUEST.SESSION['query']=string.join(self.REQUEST['QUERY_STRING'].split("&"),",")
         self.REQUEST.SESSION['come_from_search']="yes"
         
@@ -1341,7 +1613,7 @@ class ZSQLBibliography(Folder,ZSQLExtend
         else:
             return ""
     
-    def getMetaDataXML2(self):
+    def getXML2(self):
         """crate index meta"""
 
         fn=os.path.splitext(self.REQUEST['fn'])[0]+"."
@@ -1405,7 +1677,7 @@ class ZSQLBibliography(Folder,ZSQLExtend
         host_port = self.REQUEST['SERVER_PORT']
         fix_host = None
         if http_host and http_host.rfind(host_port) == -1:
-            print "HTTP_HOST needs fixing!"
+            #print "HTTP_HOST needs fixing!"
             fix_host = http_host + ":" + host_port
         
         ret="""<?xml version="1.0" ?>