Return to Index.py CVS log

Up to [Repository] / ZSQLExtend

Annotation of ZSQLExtend/Index.py, revision 1.2

1.1       dwinter     1: from BTrees.OOBTree import OOBTree
                      2: from OFS.Folder import Folder
                      3: from AccessControl import ClassSecurityInfo
                      4: from OFS.SimpleItem import SimpleItem
                      5: import re
                      6: 
                      7: class OOIndex(SimpleItem):
1.2     ! casties     8:     """classe fuer indices"""
1.1       dwinter     9:  
                     10:     security=ClassSecurityInfo()
                     11:     def __init__(self,id,results,key,value):
                     12:         self._index=OOBTree()
                     13:         self.id=id
                     14:         for result in results:
                     15:             ke=getattr(result,key)
                     16:             va=getattr(result,value)
                     17:             self._index[ke]=va
                     18:     
                     19:     def update(self,results,key,value):
                     20:         del self._index
                     21:         
                     22:         self.__init__(self.id,results, key, value)
                     23:         
                     24:     security.declarePublic("getKeys")
                     25:     def getKeys(self, pattern):
                     26:         """getkeys"""
                     27:         #method comes from Lexicon.py (globToWordIds only slightly modified
                     28:         # Implement * and ? just as in the shell, except the pattern
                     29:         # must not start with either of these
                     30:         prefix = ""
                     31:         while pattern and pattern[0] not in "*?":
                     32:             prefix += pattern[0]
                     33:             pattern = pattern[1:]
                     34:         if not pattern:
                     35:             # There were no globbing characters in the pattern
                     36:             wid = self._index.get(prefix, 0)
                     37:             if wid:
                     38:                 return [prefix]
                     39:             else:
                     40:                 return []
                     41:         if not prefix:
                     42:             # The pattern starts with a globbing character.
                     43:             # This is too efficient, so we raise an exception.
                     44:             raise QueryError(
                     45:                 "pattern %r shouldn't start with glob character" % pattern)
                     46:         pat = prefix
                     47:         for c in pattern:
                     48:             if c == "*":
                     49:                 pat += ".*"
                     50:             elif c == "?":
                     51:                 pat += "."
                     52:             else:
                     53:                 pat += re.escape(c)
                     54:         pat += "$"
                     55:         prog = re.compile(pat)
                     56:         keys = self._index.keys(prefix) # Keys starting at prefix
                     57:         wids = []
                     58:         for key in keys:
                     59:             if not key.startswith(prefix):
                     60:                 break
                     61:             if prog.match(key):
                     62:                 wids.append(key)
                     63:         return wids
                     64: 
                     65: 
                     66: class IndexManager(Folder):
                     67:     """indexManager"""
                     68:     meta_type="IndexManager"
                     69:     
                     70:     def __init__(self):
                     71:         self.id="IndexManager"
                     72:         self._indexes={}
                     73:     def createIndex(self,id,results,key,value):
                     74:         """create an index"""
                     75:         index=OOIndex(id,results,key,value)
                     76:         self._setOb(id, index)
                     77:         ob=self._getOb(id, None)
                     78:         ob.id=id
                     79:         return index
                     80:     
                     81:     def updateIndex(self,id,results,key,value):
                     82:         """update or create an index"""
                     83:         
                     84:         index=self._getOb(id, None)
                     85:         if not index:
                     86:             self.createIndex(id,results,key,value)
                     87:         else:
                     88:             index.update(results,key,value)
                     89:         
                     90:         return index
                     91:     
                     92:     def getKeysFromIndex(self,name,pattern):
                     93:         """get keys"""
                     94:         index=self._getOb(name, None)
                     95:         if not index:
                     96:             return []
                     97:         else:
                     98:             return index.getKeys(pattern)
                     99:         
                    100: def manage_addIndexManager(self):
                    101:     """add an index Manager"""
                    102:     obj=IndexManager()
                    103:     
                    104:     self._setObject("IndexManager",obj)
                    105:     
                    106: manage_addIndexManagerForm=manage_addIndexManager #no user interaction needed
                    107: 
                    108:             
                    109:         
                    110:         
                    111: