← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/btree_index.py

  • Committer: John Arbash Meinel
  • Date: 2009-12-08 21:37:36 UTC
  • mto: This revision was merged to the branch mainline in revision 4885.
  • Revision ID: john@arbash-meinel.com-20091208213736-vje7ublg3xzp1bs2
Now that we return files directly from the working tree
the windows 'attrib' test needed to be updated.
If we used the working tree for both old and new, then the test wasn't
really testing what we expected, which was that the newly generated
content was readable.

But using basis_tree gets us that. Also, test that the content is
properly marked as readonly, and that we have available content from
the working tree.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/btree_index.py
1
 
# Copyright (C) 2008, 2009, 2010 Canonical Ltd
 
1
# Copyright (C) 2008 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
567
567
                    else:
568
568
                        # yield keys
569
569
                        for value in key_dict.itervalues():
570
 
                            yield (self, ) + tuple(value)
 
570
                            yield (self, ) + value
571
571
            else:
572
572
                yield (self, ) + key_dict
573
573
 
647
647
    memory except when very large walks are done.
648
648
    """
649
649
 
650
 
    def __init__(self, transport, name, size, unlimited_cache=False,
651
 
                 offset=0):
 
650
    def __init__(self, transport, name, size, unlimited_cache=False):
652
651
        """Create a B+Tree index object on the index name.
653
652
 
654
653
        :param transport: The transport to read data for the index from.
661
660
        :param unlimited_cache: If set to True, then instead of using an
662
661
            LRUCache with size _NODE_CACHE_SIZE, we will use a dict and always
663
662
            cache all leaf nodes.
664
 
        :param offset: The start of the btree index data isn't byte 0 of the
665
 
            file. Instead it starts at some point later.
666
663
        """
667
664
        self._transport = transport
668
665
        self._name = name
670
667
        self._file = None
671
668
        self._recommended_pages = self._compute_recommended_pages()
672
669
        self._root_node = None
673
 
        self._base_offset = offset
674
670
        # Default max size is 100,000 leave values
675
671
        self._leaf_value_cache = None # lru_cache.LRUCache(100*1000)
676
672
        if unlimited_cache:
1498
1494
        # list of (offset, length) regions of the file that should, evenually
1499
1495
        # be read in to data_ranges, either from 'bytes' or from the transport
1500
1496
        ranges = []
1501
 
        base_offset = self._base_offset
1502
1497
        for index in nodes:
1503
 
            offset = (index * _PAGE_SIZE)
 
1498
            offset = index * _PAGE_SIZE
1504
1499
            size = _PAGE_SIZE
1505
1500
            if index == 0:
1506
1501
                # Root node - special case
1510
1505
                    # The only case where we don't know the size, is for very
1511
1506
                    # small indexes. So we read the whole thing
1512
1507
                    bytes = self._transport.get_bytes(self._name)
1513
 
                    num_bytes = len(bytes)
1514
 
                    self._size = num_bytes - base_offset
 
1508
                    self._size = len(bytes)
1515
1509
                    # the whole thing should be parsed out of 'bytes'
1516
 
                    ranges = [(start, min(_PAGE_SIZE, num_bytes - start))
1517
 
                        for start in xrange(base_offset, num_bytes, _PAGE_SIZE)]
 
1510
                    ranges.append((0, len(bytes)))
1518
1511
                    break
1519
1512
            else:
1520
1513
                if offset > self._size:
1522
1515
                                         ' of the file %s > %s'
1523
1516
                                         % (offset, self._size))
1524
1517
                size = min(size, self._size - offset)
1525
 
            ranges.append((base_offset + offset, size))
 
1518
            ranges.append((offset, size))
1526
1519
        if not ranges:
1527
1520
            return
1528
1521
        elif bytes is not None:
1529
1522
            # already have the whole file
1530
 
            data_ranges = [(start, bytes[start:start+size])
1531
 
                           for start, size in ranges]
 
1523
            data_ranges = [(start, bytes[start:start+_PAGE_SIZE])
 
1524
                           for start in xrange(0, len(bytes), _PAGE_SIZE)]
1532
1525
        elif self._file is None:
1533
1526
            data_ranges = self._transport.readv(self._name, ranges)
1534
1527
        else:
1537
1530
                self._file.seek(offset)
1538
1531
                data_ranges.append((offset, self._file.read(size)))
1539
1532
        for offset, data in data_ranges:
1540
 
            offset -= base_offset
1541
1533
            if offset == 0:
1542
1534
                # extract the header
1543
1535
                offset, data = self._parse_header_from_bytes(data)