← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/btree_index.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-11-17 03:20:35 UTC
  • mfrom: (4792.4.3 456036)
  • Revision ID: pqm@pqm.ubuntu.com-20091117032035-s3sgtlixj1lrminn
(Gordon Tyler) Fix IndexError during 'bzr ignore /' (#456036)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/btree_index.py
31
31
    index,
32
32
    lru_cache,
33
33
    osutils,
34
 
    static_tuple,
35
34
    trace,
36
35
    )
37
36
from bzrlib.index import _OPTION_NODE_REFS, _OPTION_KEY_ELEMENTS, _OPTION_LEN
160
159
        :param value: The value to associate with the key. It may be any
161
160
            bytes as long as it does not contain \0 or \n.
162
161
        """
163
 
        # Ensure that 'key' is a StaticTuple
164
 
        key = static_tuple.StaticTuple.from_sequence(key).intern()
165
162
        # we don't care about absent_references
166
163
        node_refs, _ = self._check_key_ref_value(key, references, value)
167
164
        if key in self._nodes:
168
165
            raise errors.BadIndexDuplicateKey(key, self)
169
 
        self._nodes[key] = static_tuple.StaticTuple(node_refs, value)
 
166
        # TODO: StaticTuple
 
167
        self._nodes[key] = (node_refs, value)
 
168
        self._keys.add(key)
170
169
        if self._nodes_by_key is not None and self._key_length > 1:
171
170
            self._update_nodes_by_key(key, value, node_refs)
172
 
        if len(self._nodes) < self._spill_at:
 
171
        if len(self._keys) < self._spill_at:
173
172
            return
174
173
        self._spill_mem_keys_to_disk()
175
174
 
204
203
                self._backing_indices[backing_pos] = None
205
204
        else:
206
205
            self._backing_indices.append(new_backing)
 
206
        self._keys = set()
207
207
        self._nodes = {}
208
208
        self._nodes_by_key = None
209
209
 
463
463
            efficient order for the index (keys iteration order in this case).
464
464
        """
465
465
        keys = set(keys)
466
 
        # Note: We don't use keys.intersection() here. If you read the C api,
467
 
        #       set.intersection(other) special cases when other is a set and
468
 
        #       will iterate the smaller of the two and lookup in the other.
469
 
        #       It does *not* do this for any other type (even dict, unlike
470
 
        #       some other set functions.) Since we expect keys is generally <<
471
 
        #       self._nodes, it is faster to iterate over it in a list
472
 
        #       comprehension
473
 
        nodes = self._nodes
474
 
        local_keys = [key for key in keys if key in nodes]
 
466
        local_keys = keys.intersection(self._keys)
475
467
        if self.reference_lists:
476
468
            for key in local_keys:
477
 
                node = nodes[key]
 
469
                node = self._nodes[key]
478
470
                yield self, key, node[1], node[0]
479
471
        else:
480
472
            for key in local_keys:
481
 
                node = nodes[key]
 
473
                node = self._nodes[key]
482
474
                yield self, key, node[1]
483
475
        # Find things that are in backing indices that have not been handled
484
476
        # yet.
594
586
 
595
587
        For InMemoryGraphIndex the estimate is exact.
596
588
        """
597
 
        return len(self._nodes) + sum(backing.key_count() for backing in
 
589
        return len(self._keys) + sum(backing.key_count() for backing in
598
590
            self._backing_indices if backing is not None)
599
591
 
600
592
    def validate(self):
632
624
    def _parse_lines(self, lines):
633
625
        nodes = []
634
626
        self.offset = int(lines[1][7:])
635
 
        as_st = static_tuple.StaticTuple.from_sequence
636
627
        for line in lines[2:]:
637
628
            if line == '':
638
629
                break
639
 
            nodes.append(as_st(map(intern, line.split('\0'))).intern())
 
630
            # TODO: Switch to StaticTuple here.
 
631
            nodes.append(tuple(map(intern, line.split('\0'))))
640
632
        return nodes
641
633
 
642
634