Contact: fumanchu@aminus.org

Log in as guest/dejavu to create tickets

I think I've seen this ORM somewhere before...

Changeset 483

Show
Ignore:
Timestamp:
09/11/07 02:33:51
Author:
fumanchu
Message:

Some backward-incompatible API changes (in order to make the sandbox and store interfaces simpler and more similar).

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/dejavu/sandboxes.py

    r482 r483  
    6464                    for arg, key in zip(args, uniq): 
    6565                        kwargs[str(key)] = arg 
    66                     expr = logic.filter(**kwargs) 
    67                     try: 
    68                         return self.xrecall(cls, expr).next() 
    69                     except StopIteration: 
    70                         return None 
     66                    return self.unit(cls, logic.filter(**kwargs)) 
    7167                recaller.__doc__ = "A single %s Unit, else None." % name 
    7268                return recaller 
    …… 
    117113            unit.sandbox = None 
    118114     
    119     def xrecall(self, relation, expr=None, inherit=False, **kwargs): 
     115    def xrecall(self, classes, expr=None, inherit=False, **kwargs): 
    120116        """Iterator over units of the given class(es) which match expr. 
    121117         
    …… 
    123119        subclasses of the given class will be recalled. 
    124120         
    125         If the 'relation' arg is a UnitJoin, each yielded value will 
    126         be a list of Units, in the same order as the relation arg. 
     121        If the 'classes' arg is a UnitJoin, each yielded value will 
     122        be a list of Units, in the same order as the classes arg. 
    127123        This facilitates unpacking in iterative consumer code like: 
    128124         
    …… 
    141137                multiple classes. 
    142138        """ 
    143         if isinstance(relation, dejavu.UnitJoin): 
    144             for unitrow in self._xmulti(relation, expr, **kwargs): 
     139        if isinstance(classes, dejavu.UnitJoin): 
     140            for unitrow in self._xmultirecall(classes, expr, **kwargs): 
    145141                yield unitrow 
    146142            return 
    147143         
    148         cls = relation 
     144        cls = classes 
    149145        expr = logic.combine(expr, kwargs) 
    150146         
    …… 
    223219                        yield unit 
    224220     
    225     def recall(self, relation, expr=None, inherit=False, **kwargs): 
     221    def recall(self, classes, expr=None, inherit=False, **kwargs): 
    226222        """List of units of the given class(es) which match expr. 
    227223         
    …… 
    229225        subclasses of the given class will be recalled. 
    230226         
    231         If the 'relation' arg is a UnitJoin, each yielded value will 
    232         be a list of Units, in the same order as the relation arg. 
     227        If the 'classes' arg is a UnitJoin, each yielded value will 
     228        be a list of Units, in the same order as the classes arg. 
    233229        This facilitates unpacking in iterative consumer code like: 
    234230         
    …… 
    247243                multiple classes. 
    248244        """ 
    249         return [x for x in self.xrecall(relation, expr, inherit, **kwargs)] 
    250      
    251     def _xmulti(self, relation, expr=None, **kwargs): 
     245        return [x for x in self.xrecall(classes, expr, inherit, **kwargs)] 
     246     
     247    def unit(self, classes, expr=None, **kwargs): 
     248        """A single Unit/Unit set which matches the given expr, else None. 
     249         
     250        **kwargs will be combined into an Expression via logic.filter. 
     251         
     252        The first Unit (or set of Units, if 'classes' is a UnitJoin) 
     253        matching the expression is returned; if no Units match, None 
     254        is returned. 
     255        """ 
     256        expr = logic.combine(expr, kwargs) 
     257         
     258        try: 
     259            if isinstance(classes, dejavu.UnitJoin): 
     260                return self._xmultirecall(classes, expr).next() 
     261            else: 
     262                return self.xrecall(classes, expr).next() 
     263        except StopIteration: 
     264            return None 
     265     
     266    def _xmultirecall(self, classes, expr=None, **kwargs): 
    252267        """Recall units of each cls if they together match the expr. 
    253268         
    254         The 'relation' arg must be a UnitJoin, and each yielded value 
    255         will be a list of Units, in the same order as the relation arg. 
     269        The 'classes' arg must be a UnitJoin, and each yielded value 
     270        will be a list of Units, in the same order as the classes arg. 
    256271        This facilitates unpacking in iterative consumer code like: 
    257272         
    …… 
    278293        # in the resultset. If you're using xmulti with no expr's, or 
    279294        # in read-only scripts, it should be OK for now. But if you mutate 
    280         # Units and then call multirecall, expect inconsistent results. 
    281         for unitset in self.store.multirecall(relation, expr): 
     295        # Units and then call _multirecall, expect inconsistent results. 
     296        for unitset in self.store._xmultirecall(classes, expr): 
    282297            confirmed = True 
    283298            for index in xrange(len(unitset)): 
    …… 
    300315                yield unitset 
    301316     
    302     def unit(self, cls, expr=None, inherit=False, **kwargs): 
    303         """A single Unit which matches the given expr, else None. 
    304          
    305         If inherit is True, the given class and all registered subclasses 
    306         of the given class will be searched for a matching Unit. 
    307          
    308         **kwargs will be combined into an Expression via logic.filter. 
    309         The first Unit matching that expression is returned; if no 
    310         Units match, None is returned. 
    311         """ 
    312         try: 
    313             return self.xrecall(cls, expr, inherit, **kwargs).next() 
    314         except StopIteration: 
    315             return None 
    316      
    317317    def xview(self, query, distinct=False): 
    318318        """Yield tuples of attrs for the given Query. 

  • trunk/dejavu/storage/__init__.py

    r482 r483  
    203203        raise NotImplementedError 
    204204     
    205     def xrecall(self, cls, expr=None, order=None, limit=None, offset=None): 
     205    def xrecall(self, classes, expr=None, order=None, limit=None, offset=None): 
    206206        """Return an iterable of Units.""" 
     207        if isinstance(classes, dejavu.UnitJoin): 
     208            for unitrow in self._xmultirecall(classes, expr, order=order, 
     209                                              limit=limit, offset=offset): 
     210                yield unitrow 
     211            return 
     212         
    207213        raise NotImplementedError 
    208214     
    209     def recall(self, cls, expr=None, order=None, limit=None, offset=None): 
     215    def recall(self, classes, expr=None, order=None, limit=None, offset=None): 
    210216        """Return a sequence of Unit instances which satisfy the expression.""" 
    211         return [x for x in self.xrecall(cls, expr, order, limit, offset)] 
     217        return [x for x in self.xrecall(classes, expr, order=order, 
     218                                        limit=limit, offset=offset)] 
     219     
     220    def unit(self, classes, expr=None, **kwargs): 
     221        """A single Unit/Unit set which matches the given expr, else None. 
     222         
     223        **kwargs will be combined into an Expression via logic.filter. 
     224         
     225        The first Unit (or set of Units, if 'classes' is a UnitJoin) 
     226        matching the expression is returned; if no Units match, None 
     227        is returned. 
     228        """ 
     229        expr = logic.combine(expr, kwargs) 
     230         
     231        try: 
     232            if isinstance(classes, dejavu.UnitJoin): 
     233                return self._xmultirecall(classes, expr).next() 
     234            else: 
     235                return self.xrecall(classes, expr).next() 
     236        except StopIteration: 
     237            return None 
    212238     
    213239    def _paginate(self, data, order=None, limit=None, offset=None): 
    …… 
    238264    #                                Views                                # 
    239265    # 
    240     # The _combine, view, xview, and multirecall method given below use 
     266    # The _combine, view, xview, and _multirecall method given below use 
    241267    # self.recall to retrieve entire Units, and then slice and dice them 
    242268    # in memory. This is quite slow; you should *definitely* override 
    …… 
    327353                    yield [unit.__class__() for unit in row1] + row2 
    328354     
    329     def xmultirecall(self, classes, expr=None, order=None, limit=None, offset=None): 
     355    def _xmultirecall(self, classes, expr=None, order=None, limit=None, offset=None): 
    330356        """Yield lists of units of the given classes which match expr.""" 
    331357        if expr is None: 
    …… 
    340366                if expr(*unitrow): 
    341367                    yield unitrow 
    342         return self._paginate(_combine_inner, order, limit, offset) 
    343      
    344     def multirecall(self, classes, expr=None, order=None, limit=None, offset=None): 
     368        return self._paginate(_combine_inner(), order, limit, offset) 
     369     
     370    def _multirecall(self, classes, expr=None, order=None, limit=None, offset=None): 
    345371        """Return lists of units which satisfy the expression.""" 
    346         return [t for t in self.xmultirecall(classes, expr=None, order=None, 
    347                                              limit=None, offset=None)] 
     372        return [t for t in self._xmultirecall(classes, expr=None, order=None, 
     373                                              limit=None, offset=None)] 
    348374     
    349375    def xview(self, query, distinct=False): 
    …… 
    494520        self.nextstore = allOptions.get('Next Store') 
    495521     
    496     def xrecall(self, cls, expr=None, order=None, limit=None, offset=None): 
     522    def xrecall(self, classes, expr=None, order=None, limit=None, offset=None): 
     523        if isinstance(classes, dejavu.UnitJoin): 
     524            for unitrow in self._xmultirecall(classes, expr, order=order, 
     525                                              limit=limit, offset=offset): 
     526                yield unitrow 
     527            return 
     528         
     529        cls = classes 
    497530        if self.logflags & logflags.RECALL: 
    498531            self.log(logflags.RECALL.message(cls, expr)) 
    499         for unit in self.nextstore.xrecall(cls, expr, order, limit, offset): 
     532        for unit in self.nextstore.xrecall(cls, expr, order=order, 
     533                                           limit=limit, offset=offset): 
    500534            yield unit 
    501535     
    …… 
    530564        return self.nextstore.xview(query, distinct) 
    531565     
    532     def xmultirecall(self, classes, expr=None, order=None, limit=None, offset=None): 
     566    def _xmultirecall(self, classes, expr=None, order=None, limit=None, offset=None): 
    533567        """Full inner join units from each class.""" 
    534568        if self.logflags & logflags.RECALL: 
    535569            self.log(logflags.RECALL.message(classes, expr)) 
    536         return self.nextstore.xmultirecall(classes, expr, order, limit, offset) 
     570        return self.nextstore._xmultirecall(classes, expr, order, limit, offset) 
    537571     
    538572    def count(self, cls, expr=None): 
    …… 
    624658        self.cache = resolve("ram") 
    625659     
    626     def xrecall(self, cls, expr=None, order=None, limit=None, offset=None): 
     660    def xrecall(self, classes, expr=None, order=None, limit=None, offset=None): 
    627661        """Return a Unit iterator.""" 
     662        if isinstance(classes, dejavu.UnitJoin): 
     663            return self._xmultirecall(classes, expr, order=order, 
     664                                      limit=limit, offset=offset) 
     665         
     666        cls = classes 
    628667        # Units which have no identifiers are not cached 
    629668        if not cls.identifiers: 
    630             return ProxyStorage.xrecall(self, cls, expr, order, limit, offset) 
     669            return ProxyStorage.xrecall(self, cls, expr, order=order, 
     670                                        limit=limit, offset=offset) 
    631671        else: 
    632672            if self.logflags & logflags.RECALL: 
    …… 
    794834            self.sweeper = IdleSweeper(lifetime) 
    795835     
    796     def xrecall(self, cls, expr=None, order=None, limit=None, offset=None): 
     836    def xrecall(self, classes, expr=None, order=None, limit=None, offset=None): 
    797837        """Return a Unit iterator.""" 
     838        if isinstance(classes, dejavu.UnitJoin): 
     839            for unitrow in self._xmultirecall(classes, expr, order=order, 
     840                                              limit=limit, offset=offset): 
     841                yield unitrow 
     842            return 
     843         
     844        cls = classes 
    798845        start = datetime.datetime.now() 
    799846        recallTimes = self._recallTimes.setdefault(cls, {}) 
    …… 
    843890    """ 
    844891     
    845     def xrecall(self, cls, expr=None, order=None, limit=None, offset=None): 
     892    def xrecall(self, classes, expr=None, order=None, limit=None, offset=None): 
    846893        """Return a Unit iterator.""" 
     894        if isinstance(classes, dejavu.UnitJoin): 
     895            return self._xmultirecall(classes, expr, order=order, 
     896                                      limit=limit, offset=offset) 
     897         
     898        cls = classes 
    847899        # Units which have no identifiers are not cached 
    848900        if not cls.identifiers: 
    849             return ProxyStorage.xrecall(self, cls, expr, order, limit, offset) 
     901            return ProxyStorage.xrecall(self, cls, expr, order=order, 
     902                                        limit=limit, offset=offset) 
    850903        else: 
    851904            if self.logflags & logflags.RECALL: 

  • trunk/dejavu/storage/db.py

    r482 r483  
    8383        self.db.connections.shutdown() 
    8484     
    85     def xrecall(self, cls, expr=None, order=None, limit=None, offset=None): 
     85    def xrecall(self, classes, expr=None, order=None, limit=None, offset=None): 
    8686        """Yield a sequence of Unit instances which satisfy the expression.""" 
     87        if isinstance(classes, dejavu.UnitJoin): 
     88            for unitrow in self._xmultirecall(classes, expr, order=None, 
     89                                              limit=None, offset=None): 
     90                yield unitrow 
     91            return 
     92        else: 
     93            cls = classes 
     94         
    8795        if self.logflags & logflags.RECALL: 
    8896            self.log(logflags.RECALL.message(cls, expr)) 
    …… 
    293301            return data.scalar() 
    294302     
    295     def xmultirecall(self, classes, expr=None, order=None, limit=None, offset=None): 
     303    def _xmultirecall(self, classes, expr=None, order=None, limit=None, offset=None): 
    296304        """Yield Unit instance sets which satisfy the expression.""" 
    297305        if self.logflags & logflags.RECALL: 

  • trunk/dejavu/storage/partitions.py

    r482 r483  
    241241        self.storage(unit.__class__).destroy(unit) 
    242242     
    243     def xrecall(self, cls, expr=None, order=None, limit=None, offset=None): 
     243    def xrecall(self, classes, expr=None, order=None, limit=None, offset=None): 
    244244        """Yield a sequence of Unit instances which satisfy the expression.""" 
    245         if isinstance(cls, dejavu.UnitJoin): 
    246             for unitrow in self.multirecall(cls, expr): 
     245        if isinstance(classes, dejavu.UnitJoin): 
     246            for unitrow in self._xmultirecall(classes, expr, order=None, 
     247                                              limit=None, offset=None): 
    247248                yield unitrow 
    248249        else: 
    249             for unit in self.storage(cls).xrecall(cls, expr, order, 
    250                                                   limit, offset): 
     250            for unit in self.storage(classes).xrecall( 
     251                    cls, expr, order, limit, offset): 
    251252                yield unit 
    252253     
    253     def xmultirecall(self, classes, expr=None, order=None, limit=None, offset=None): 
     254    def _xmultirecall(self, classes, expr=None, order=None, limit=None, offset=None): 
    254255        """Yield lists of units of the given classes which match expr. 
    255256         
    …… 
    259260            expr = logic.Expression(lambda *args: True) 
    260261         
    261         return self._single_store(classes).xmultirecall(classes, expr, order, 
    262                                                         limit, offset) 
     262        return self._single_store(classes)._xmultirecall(classes, expr, order, 
     263                                                        limit, offset) 
    263264     
    264265    def _single_store(self, relation): 

  • trunk/dejavu/storage/storefs.py

    r482 r483  
    103103        return unitdict 
    104104     
    105     def xrecall(self, cls, expr=None, order=None, limit=None, offset=None): 
     105    def xrecall(self, classes, expr=None, order=None, limit=None, offset=None): 
     106        if isinstance(classes, dejavu.UnitJoin): 
     107            return self._xmultirecall(classes, expr, order=order, 
     108                                      limit=limit, offset=offset) 
     109         
     110        cls = classes 
    106111        if self.logflags & logflags.RECALL: 
    107112            self.log(logflags.RECALL.message(cls, expr)) 

  • trunk/dejavu/storage/storeram.py

    r482 r483  
    2323        return lock 
    2424     
    25     def xrecall(self, cls, expr=None, order=None, limit=None, offset=None): 
     25    def xrecall(self, classes, expr=None, order=None, limit=None, offset=None): 
    2626        """Yield units of the given cls which match the given expr.""" 
     27        if isinstance(classes, dejavu.UnitJoin): 
     28            return self._xmultirecall(classes, expr, order=order, 
     29                                      limit=limit, offset=offset) 
     30         
     31        cls = classes 
    2732        if self.logflags & logflags.RECALL: 
    2833            self.log(logflags.RECALL.message(cls, expr)) 

  • trunk/dejavu/storage/storeshelve.py

    r482 r483  
    5959        return s 
    6060     
    61     def xrecall(self, cls, expr=None, order=None, limit=None, offset=None): 
     61    def xrecall(self, classes, expr=None, order=None, limit=None, offset=None): 
    6262        """Yield units of the given cls which match the given expr.""" 
     63        if isinstance(classes, dejavu.UnitJoin): 
     64            return self._xmultirecall(classes, expr, order=order, 
     65                                      limit=limit, offset=offset) 
     66         
     67        cls = classes 
    6368        if self.logflags & logflags.RECALL: 
    6469            self.log(logflags.RECALL.message(cls, expr))