/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/btree_index.py

  • Committer: Andrew Bennetts
  • Date: 2008-11-27 06:29:56 UTC
  • mfrom: (3861 +trunk)
  • mto: This revision was merged to the branch mainline in revision 3863.
  • Revision ID: andrew.bennetts@canonical.com-20081127062956-v0a19icwk85iosx4
Merge bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/btree_index.py
431
431
            efficient order for the index (keys iteration order in this case).
432
432
        """
433
433
        keys = set(keys)
 
434
        local_keys = keys.intersection(self._keys)
434
435
        if self.reference_lists:
435
 
            for key in keys.intersection(self._keys):
 
436
            for key in local_keys:
436
437
                node = self._nodes[key]
437
438
                yield self, key, node[1], node[0]
438
439
        else:
439
 
            for key in keys.intersection(self._keys):
 
440
            for key in local_keys:
440
441
                node = self._nodes[key]
441
442
                yield self, key, node[1]
442
 
        keys.difference_update(self._keys)
 
443
        # Find things that are in backing indices that have not been handled
 
444
        # yet.
 
445
        if not self._backing_indices:
 
446
            return # We won't find anything there either
 
447
        # Remove all of the keys that we found locally
 
448
        keys.difference_update(local_keys)
443
449
        for backing in self._backing_indices:
444
450
            if backing is None:
445
451
                continue
848
854
        """
849
855
        return self._get_nodes(self._internal_node_cache, node_indexes)
850
856
 
851
 
    def _get_leaf_nodes(self, node_indexes):
852
 
        """Get a bunch of nodes, from cache or disk."""
853
 
        found = self._get_nodes(self._leaf_node_cache, node_indexes)
 
857
    def _cache_leaf_values(self, nodes):
 
858
        """Cache directly from key => value, skipping the btree."""
854
859
        if self._leaf_value_cache is not None:
855
 
            for node in found.itervalues():
 
860
            for node in nodes.itervalues():
856
861
                for key, value in node.keys.iteritems():
857
862
                    if key in self._leaf_value_cache:
858
863
                        # Don't add the rest of the keys, we've seen this node
859
864
                        # before.
860
865
                        break
861
866
                    self._leaf_value_cache[key] = value
 
867
 
 
868
    def _get_leaf_nodes(self, node_indexes):
 
869
        """Get a bunch of nodes, from cache or disk."""
 
870
        found = self._get_nodes(self._leaf_node_cache, node_indexes)
 
871
        self._cache_leaf_values(found)
862
872
        return found
863
873
 
864
874
    def iter_all_entries(self):
877
887
            return
878
888
        start_of_leaves = self._row_offsets[-2]
879
889
        end_of_leaves = self._row_offsets[-1]
880
 
        needed_nodes = range(start_of_leaves, end_of_leaves)
 
890
        needed_offsets = range(start_of_leaves, end_of_leaves)
 
891
        if needed_offsets == [0]:
 
892
            # Special case when we only have a root node, as we have already
 
893
            # read everything
 
894
            nodes = [(0, self._root_node)]
 
895
        else:
 
896
            nodes = self._read_nodes(needed_offsets)
881
897
        # We iterate strictly in-order so that we can use this function
882
898
        # for spilling index builds to disk.
883
899
        if self.node_ref_lists:
884
 
            for _, node in self._read_nodes(needed_nodes):
 
900
            for _, node in nodes:
885
901
                for key, (value, refs) in sorted(node.keys.items()):
886
902
                    yield (self, key, value, refs)
887
903
        else:
888
 
            for _, node in self._read_nodes(needed_nodes):
 
904
            for _, node in nodes:
889
905
                for key, (value, refs) in sorted(node.keys.items()):
890
906
                    yield (self, key, value)
891
907
 
1242
1258
        :param nodes: The nodes to read. 0 - first node, 1 - second node etc.
1243
1259
        :return: None
1244
1260
        """
 
1261
        bytes = None
1245
1262
        ranges = []
1246
1263
        for index in nodes:
1247
1264
            offset = index * _PAGE_SIZE
1251
1268
                if self._size:
1252
1269
                    size = min(_PAGE_SIZE, self._size)
1253
1270
                else:
1254
 
                    stream = self._transport.get(self._name)
1255
 
                    start = stream.read(_PAGE_SIZE)
1256
 
                    # Avoid doing this again
1257
 
                    self._size = len(start)
1258
 
                    size = min(_PAGE_SIZE, self._size)
 
1271
                    # The only case where we don't know the size, is for very
 
1272
                    # small indexes. So we read the whole thing
 
1273
                    bytes = self._transport.get_bytes(self._name)
 
1274
                    self._size = len(bytes)
 
1275
                    ranges.append((0, len(bytes)))
 
1276
                    break
1259
1277
            else:
1260
1278
                if offset > self._size:
1261
1279
                    raise AssertionError('tried to read past the end'
1265
1283
            ranges.append((offset, size))
1266
1284
        if not ranges:
1267
1285
            return
1268
 
        if self._file is None:
 
1286
        if bytes:
 
1287
            data_ranges = [(offset, bytes[offset:offset+_PAGE_SIZE])
 
1288
                           for offset in xrange(0, len(bytes), _PAGE_SIZE)]
 
1289
        elif self._file is None:
1269
1290
            data_ranges = self._transport.readv(self._name, ranges)
1270
1291
        else:
1271
1292
            data_ranges = []