← 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: 2008-11-28 03:17:39 UTC
  • mfrom: (3868.1.1 integration)
  • Revision ID: pqm@pqm.ubuntu.com-20081128031739-mprtvyhcn9zwtkqc
(mbp, for jam) bzr branch opens source branch only once

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/btree_index.py
885
885
                "iter_all_entries scales with size of history.")
886
886
        if not self.key_count():
887
887
            return
 
888
        if self._row_offsets[-1] == 1:
 
889
            # There is only the root node, and we read that via key_count()
 
890
            if self.node_ref_lists:
 
891
                for key, (value, refs) in sorted(self._root_node.keys.items()):
 
892
                    yield (self, key, value, refs)
 
893
            else:
 
894
                for key, (value, refs) in sorted(self._root_node.keys.items()):
 
895
                    yield (self, key, value)
 
896
            return
888
897
        start_of_leaves = self._row_offsets[-2]
889
898
        end_of_leaves = self._row_offsets[-1]
890
899
        needed_offsets = range(start_of_leaves, end_of_leaves)
1251
1260
        """Read some nodes from disk into the LRU cache.
1252
1261
 
1253
1262
        This performs a readv to get the node data into memory, and parses each
1254
 
        node, the yields it to the caller. The nodes are requested in the
 
1263
        node, then yields it to the caller. The nodes are requested in the
1255
1264
        supplied order. If possible doing sort() on the list before requesting
1256
1265
        a read may improve performance.
1257
1266
 
1258
1267
        :param nodes: The nodes to read. 0 - first node, 1 - second node etc.
1259
1268
        :return: None
1260
1269
        """
 
1270
        # may be the byte string of the whole file
1261
1271
        bytes = None
 
1272
        # list of (offset, length) regions of the file that should, evenually
 
1273
        # be read in to data_ranges, either from 'bytes' or from the transport
1262
1274
        ranges = []
1263
1275
        for index in nodes:
1264
1276
            offset = index * _PAGE_SIZE
1272
1284
                    # small indexes. So we read the whole thing
1273
1285
                    bytes = self._transport.get_bytes(self._name)
1274
1286
                    self._size = len(bytes)
 
1287
                    # the whole thing should be parsed out of 'bytes'
1275
1288
                    ranges.append((0, len(bytes)))
1276
1289
                    break
1277
1290
            else:
1283
1296
            ranges.append((offset, size))
1284
1297
        if not ranges:
1285
1298
            return
1286
 
        if bytes:
1287
 
            data_ranges = [(offset, bytes[offset:offset+_PAGE_SIZE])
1288
 
                           for offset in xrange(0, len(bytes), _PAGE_SIZE)]
 
1299
        elif bytes is not None:
 
1300
            # already have the whole file
 
1301
            data_ranges = [(start, bytes[start:start+_PAGE_SIZE])
 
1302
                           for start in xrange(0, len(bytes), _PAGE_SIZE)]
1289
1303
        elif self._file is None:
1290
1304
            data_ranges = self._transport.readv(self._name, ranges)
1291
1305
        else: