Return to Index.py CVS log

Up to [Repository] / ZSQLExtend

Annotation of ZSQLExtend/Index.py, revision 1.1

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):
        !             8:     """classe fŸr indices"""
        !             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: