1
# Copyright (C) 2007 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
"""Indexing facilities."""
23
'GraphIndexPrefixAdapter',
27
from bisect import bisect_right
28
from cStringIO import StringIO
31
from bzrlib.lazy_import import lazy_import
32
lazy_import(globals(), """
33
from bzrlib import trace
34
from bzrlib.bisect_multi import bisect_multi_bytes
35
from bzrlib.trace import mutter
37
from bzrlib import debug, errors
39
_OPTION_KEY_ELEMENTS = "key_elements="
41
_OPTION_NODE_REFS = "node_ref_lists="
42
_SIGNATURE = "Bazaar Graph Index 1\n"
45
_whitespace_re = re.compile('[\t\n\x0b\x0c\r\x00 ]')
46
_newline_null_re = re.compile('[\n\0]')
49
class GraphIndexBuilder(object):
50
"""A builder that can build a GraphIndex.
52
The resulting graph has the structure:
54
_SIGNATURE OPTIONS NODES NEWLINE
55
_SIGNATURE := 'Bazaar Graph Index 1' NEWLINE
56
OPTIONS := 'node_ref_lists=' DIGITS NEWLINE
58
NODE := KEY NULL ABSENT? NULL REFERENCES NULL VALUE NEWLINE
59
KEY := Not-whitespace-utf8
61
REFERENCES := REFERENCE_LIST (TAB REFERENCE_LIST){node_ref_lists - 1}
62
REFERENCE_LIST := (REFERENCE (CR REFERENCE)*)?
63
REFERENCE := DIGITS ; digits is the byte offset in the index of the
65
VALUE := no-newline-no-null-bytes
68
def __init__(self, reference_lists=0, key_elements=1):
69
"""Create a GraphIndex builder.
71
:param reference_lists: The number of node references lists for each
73
:param key_elements: The number of bytestrings in each key.
75
self.reference_lists = reference_lists
78
self._nodes_by_key = {}
79
self._key_length = key_elements
81
def _check_key(self, key):
82
"""Raise BadIndexKey if key is not a valid key for this index."""
83
if type(key) != tuple:
84
raise errors.BadIndexKey(key)
85
if self._key_length != len(key):
86
raise errors.BadIndexKey(key)
88
if not element or _whitespace_re.search(element) is not None:
89
raise errors.BadIndexKey(element)
91
def add_node(self, key, value, references=()):
92
"""Add a node to the index.
94
:param key: The key. keys are non-empty tuples containing
95
as many whitespace-free utf8 bytestrings as the key length
96
defined for this index.
97
:param references: An iterable of iterables of keys. Each is a
98
reference to another key.
99
:param value: The value to associate with the key. It may be any
100
bytes as long as it does not contain \0 or \n.
103
if _newline_null_re.search(value) is not None:
104
raise errors.BadIndexValue(value)
105
if len(references) != self.reference_lists:
106
raise errors.BadIndexValue(references)
108
for reference_list in references:
109
for reference in reference_list:
110
self._check_key(reference)
111
if reference not in self._nodes:
112
self._nodes[reference] = ('a', (), '')
113
node_refs.append(tuple(reference_list))
114
if key in self._nodes and self._nodes[key][0] == '':
115
raise errors.BadIndexDuplicateKey(key, self)
116
self._nodes[key] = ('', tuple(node_refs), value)
118
if self._key_length > 1:
119
key_dict = self._nodes_by_key
120
if self.reference_lists:
121
key_value = key, value, tuple(node_refs)
123
key_value = key, value
124
# possibly should do this on-demand, but it seems likely it is
126
# For a key of (foo, bar, baz) create
127
# _nodes_by_key[foo][bar][baz] = key_value
128
for subkey in key[:-1]:
129
key_dict = key_dict.setdefault(subkey, {})
130
key_dict[key[-1]] = key_value
134
lines.append(_OPTION_NODE_REFS + str(self.reference_lists) + '\n')
135
lines.append(_OPTION_KEY_ELEMENTS + str(self._key_length) + '\n')
136
lines.append(_OPTION_LEN + str(len(self._keys)) + '\n')
137
prefix_length = sum(len(x) for x in lines)
138
# references are byte offsets. To avoid having to do nasty
139
# polynomial work to resolve offsets (references to later in the
140
# file cannot be determined until all the inbetween references have
141
# been calculated too) we pad the offsets with 0's to make them be
142
# of consistent length. Using binary offsets would break the trivial
144
# to calculate the width of zero's needed we do three passes:
145
# one to gather all the non-reference data and the number of references.
146
# one to pad all the data with reference-length and determine entry
150
# forward sorted by key. In future we may consider topological sorting,
151
# at the cost of table scans for direct lookup, or a second index for
153
nodes = sorted(self._nodes.items())
154
# if we do not prepass, we don't know how long it will be up front.
155
expected_bytes = None
156
# we only need to pre-pass if we have reference lists at all.
157
if self.reference_lists:
159
non_ref_bytes = prefix_length
161
# TODO use simple multiplication for the constants in this loop.
162
for key, (absent, references, value) in nodes:
163
# record the offset known *so far* for this key:
164
# the non reference bytes to date, and the total references to
165
# date - saves reaccumulating on the second pass
166
key_offset_info.append((key, non_ref_bytes, total_references))
167
# key is literal, value is literal, there are 3 null's, 1 NL
168
# key is variable length tuple, \x00 between elements
169
non_ref_bytes += sum(len(element) for element in key)
170
if self._key_length > 1:
171
non_ref_bytes += self._key_length - 1
172
# value is literal bytes, there are 3 null's, 1 NL.
173
non_ref_bytes += len(value) + 3 + 1
174
# one byte for absent if set.
177
elif self.reference_lists:
178
# (ref_lists -1) tabs
179
non_ref_bytes += self.reference_lists - 1
180
# (ref-1 cr's per ref_list)
181
for ref_list in references:
182
# how many references across the whole file?
183
total_references += len(ref_list)
184
# accrue reference separators
186
non_ref_bytes += len(ref_list) - 1
187
# how many digits are needed to represent the total byte count?
189
possible_total_bytes = non_ref_bytes + total_references*digits
190
while 10 ** digits < possible_total_bytes:
192
possible_total_bytes = non_ref_bytes + total_references*digits
193
expected_bytes = possible_total_bytes + 1 # terminating newline
194
# resolve key addresses.
196
for key, non_ref_bytes, total_references in key_offset_info:
197
key_addresses[key] = non_ref_bytes + total_references*digits
199
format_string = '%%0%sd' % digits
200
for key, (absent, references, value) in nodes:
201
flattened_references = []
202
for ref_list in references:
204
for reference in ref_list:
205
ref_addresses.append(format_string % key_addresses[reference])
206
flattened_references.append('\r'.join(ref_addresses))
207
string_key = '\x00'.join(key)
208
lines.append("%s\x00%s\x00%s\x00%s\n" % (string_key, absent,
209
'\t'.join(flattened_references), value))
211
result = StringIO(''.join(lines))
212
if expected_bytes and len(result.getvalue()) != expected_bytes:
213
raise errors.BzrError('Failed index creation. Internal error:'
214
' mismatched output length and expected length: %d %d' %
215
(len(result.getvalue()), expected_bytes))
216
return StringIO(''.join(lines))
219
class GraphIndex(object):
220
"""An index for data with embedded graphs.
222
The index maps keys to a list of key reference lists, and a value.
223
Each node has the same number of key reference lists. Each key reference
224
list can be empty or an arbitrary length. The value is an opaque NULL
225
terminated string without any newlines. The storage of the index is
226
hidden in the interface: keys and key references are always tuples of
227
bytestrings, never the internal representation (e.g. dictionary offsets).
229
It is presumed that the index will not be mutated - it is static data.
231
Successive iter_all_entries calls will read the entire index each time.
232
Additionally, iter_entries calls will read the index linearly until the
233
desired keys are found. XXX: This must be fixed before the index is
234
suitable for production use. :XXX
237
def __init__(self, transport, name, size):
238
"""Open an index called name on transport.
240
:param transport: A bzrlib.transport.Transport.
241
:param name: A path to provide to transport API calls.
242
:param size: The size of the index in bytes. This is used for bisection
243
logic to perform partial index reads. While the size could be
244
obtained by statting the file this introduced an additional round
245
trip as well as requiring stat'able transports, both of which are
246
avoided by having it supplied. If size is None, then bisection
247
support will be disabled and accessing the index will just stream
250
self._transport = transport
252
# becomes a dict of key:(value, reference-list-byte-locations)
253
# used by the bisection interface to store parsed but not resolved
255
self._bisect_nodes = None
257
# a sorted list of slice-addresses for the parsed bytes of the file.
258
# e.g. (0,1) would mean that byte 0 is parsed.
259
self._parsed_byte_map = []
260
# a sorted list of keys matching each slice address for parsed bytes
261
# e.g. (None, 'foo@bar') would mean that the first byte contained no
262
# key, and the end byte of the slice is the of the data for 'foo@bar'
263
self._parsed_key_map = []
264
self._key_count = None
265
self._keys_by_offset = None
266
self._nodes_by_key = None
269
def _buffer_all(self):
270
"""Buffer all the index data.
272
Mutates self._nodes and self.keys_by_offset.
274
if 'index' in debug.debug_flags:
275
mutter('Reading entire index %s', self._transport.abspath(self._name))
276
stream = self._transport.get(self._name)
277
self._read_prefix(stream)
278
expected_elements = 3 + self._key_length
280
# raw data keyed by offset
281
self._keys_by_offset = {}
282
# ready-to-return key:value or key:value, node_ref_lists
284
self._nodes_by_key = {}
287
for line in stream.readlines():
291
elements = line.split('\0')
292
if len(elements) != expected_elements:
293
raise errors.BadIndexData(self)
295
key = tuple(elements[:self._key_length])
296
absent, references, value = elements[-3:]
297
value = value[:-1] # remove the newline
299
for ref_string in references.split('\t'):
300
ref_lists.append(tuple([
301
int(ref) for ref in ref_string.split('\r') if ref
303
ref_lists = tuple(ref_lists)
304
self._keys_by_offset[pos] = (key, absent, ref_lists, value)
306
for key, absent, references, value in self._keys_by_offset.itervalues():
309
# resolve references:
310
if self.node_ref_lists:
312
for ref_list in references:
313
node_refs.append(tuple([self._keys_by_offset[ref][0] for ref in ref_list]))
314
node_value = (value, tuple(node_refs))
317
self._nodes[key] = node_value
318
if self._key_length > 1:
319
subkey = list(reversed(key[:-1]))
320
key_dict = self._nodes_by_key
321
if self.node_ref_lists:
322
key_value = key, node_value[0], node_value[1]
324
key_value = key, node_value
325
# possibly should do this on-demand, but it seems likely it is
327
# For a key of (foo, bar, baz) create
328
# _nodes_by_key[foo][bar][baz] = key_value
329
for subkey in key[:-1]:
330
key_dict = key_dict.setdefault(subkey, {})
331
key_dict[key[-1]] = key_value
332
# cache the keys for quick set intersections
333
self._keys = set(self._nodes)
335
# there must be one line - the empty trailer line.
336
raise errors.BadIndexData(self)
338
def iter_all_entries(self):
339
"""Iterate over all keys within the index.
341
:return: An iterable of (index, key, value) or (index, key, value, reference_lists).
342
The former tuple is used when there are no reference lists in the
343
index, making the API compatible with simple key:value index types.
344
There is no defined order for the result iteration - it will be in
345
the most efficient order for the index.
347
if 'evil' in debug.debug_flags:
348
trace.mutter_callsite(3,
349
"iter_all_entries scales with size of history.")
350
if self._nodes is None:
352
if self.node_ref_lists:
353
for key, (value, node_ref_lists) in self._nodes.iteritems():
354
yield self, key, value, node_ref_lists
356
for key, value in self._nodes.iteritems():
357
yield self, key, value
359
def _read_prefix(self, stream):
360
signature = stream.read(len(self._signature()))
361
if not signature == self._signature():
362
raise errors.BadIndexFormatSignature(self._name, GraphIndex)
363
options_line = stream.readline()
364
if not options_line.startswith(_OPTION_NODE_REFS):
365
raise errors.BadIndexOptions(self)
367
self.node_ref_lists = int(options_line[len(_OPTION_NODE_REFS):-1])
369
raise errors.BadIndexOptions(self)
370
options_line = stream.readline()
371
if not options_line.startswith(_OPTION_KEY_ELEMENTS):
372
raise errors.BadIndexOptions(self)
374
self._key_length = int(options_line[len(_OPTION_KEY_ELEMENTS):-1])
376
raise errors.BadIndexOptions(self)
377
options_line = stream.readline()
378
if not options_line.startswith(_OPTION_LEN):
379
raise errors.BadIndexOptions(self)
381
self._key_count = int(options_line[len(_OPTION_LEN):-1])
383
raise errors.BadIndexOptions(self)
385
def _resolve_references(self, references):
386
"""Return the resolved key references for references."""
388
for ref_list in references:
389
node_refs.append(tuple([self._keys_by_offset[ref][0] for ref in ref_list]))
390
return tuple(node_refs)
392
def _find_index(self, range_map, key):
393
"""Helper for the _parsed_*_index calls.
395
Given a range map - [(start, end), ...], finds the index of the range
396
in the map for key if it is in the map, and if it is not there, the
397
immediately preceeding range in the map.
399
result = bisect_right(range_map, key) - 1
400
if result + 1 < len(range_map):
401
# check the border condition, it may be in result + 1
402
if range_map[result + 1][0] == key[0]:
406
def _parsed_byte_index(self, offset):
407
"""Return the index of the entry immediately before offset.
409
e.g. if the parsed map has regions 0,10 and 11,12 parsed, meaning that
410
there is one unparsed byte (the 11th, addressed as[10]). then:
411
asking for 0 will return 0
412
asking for 10 will return 0
413
asking for 11 will return 1
414
asking for 12 will return 1
417
return self._find_index(self._parsed_byte_map, key)
419
def _parsed_key_index(self, key):
420
"""Return the index of the entry immediately before key.
422
e.g. if the parsed map has regions (None, 'a') and ('b','c') parsed,
423
meaning that keys from None to 'a' inclusive, and 'b' to 'c' inclusive
424
have been parsed, then:
425
asking for '' will return 0
426
asking for 'a' will return 0
427
asking for 'b' will return 1
428
asking for 'e' will return 1
430
search_key = (key, None)
431
return self._find_index(self._parsed_key_map, search_key)
433
def _is_parsed(self, offset):
434
"""Returns True if offset has been parsed."""
435
index = self._parsed_byte_index(offset)
436
if index == len(self._parsed_byte_map):
437
return offset < self._parsed_byte_map[index - 1][1]
438
start, end = self._parsed_byte_map[index]
439
return offset >= start and offset < end
441
def _iter_entries_from_total_buffer(self, keys):
442
"""Iterate over keys when the entire index is parsed."""
443
keys = keys.intersection(self._keys)
444
if self.node_ref_lists:
446
value, node_refs = self._nodes[key]
447
yield self, key, value, node_refs
450
yield self, key, self._nodes[key]
452
def iter_entries(self, keys):
453
"""Iterate over keys within the index.
455
:param keys: An iterable providing the keys to be retrieved.
456
:return: An iterable as per iter_all_entries, but restricted to the
457
keys supplied. No additional keys will be returned, and every
458
key supplied that is in the index will be returned.
463
if self._size is None and self._nodes is None:
465
if self._nodes is not None:
466
return self._iter_entries_from_total_buffer(keys)
468
return (result[1] for result in bisect_multi_bytes(
469
self.lookup_keys_via_location, self._size, keys))
471
def iter_entries_prefix(self, keys):
472
"""Iterate over keys within the index using prefix matching.
474
Prefix matching is applied within the tuple of a key, not to within
475
the bytestring of each key element. e.g. if you have the keys ('foo',
476
'bar'), ('foobar', 'gam') and do a prefix search for ('foo', None) then
477
only the former key is returned.
479
WARNING: Note that this method currently causes a full index parse
480
unconditionally (which is reasonably appropriate as it is a means for
481
thunking many small indices into one larger one and still supplies
482
iter_all_entries at the thunk layer).
484
:param keys: An iterable providing the key prefixes to be retrieved.
485
Each key prefix takes the form of a tuple the length of a key, but
486
with the last N elements 'None' rather than a regular bytestring.
487
The first element cannot be 'None'.
488
:return: An iterable as per iter_all_entries, but restricted to the
489
keys with a matching prefix to those supplied. No additional keys
490
will be returned, and every match that is in the index will be
496
# load data - also finds key lengths
497
if self._nodes is None:
499
if self._key_length == 1:
503
raise errors.BadIndexKey(key)
504
if len(key) != self._key_length:
505
raise errors.BadIndexKey(key)
506
if self.node_ref_lists:
507
value, node_refs = self._nodes[key]
508
yield self, key, value, node_refs
510
yield self, key, self._nodes[key]
515
raise errors.BadIndexKey(key)
516
if len(key) != self._key_length:
517
raise errors.BadIndexKey(key)
518
# find what it refers to:
519
key_dict = self._nodes_by_key
521
# find the subdict whose contents should be returned.
523
while len(elements) and elements[0] is not None:
524
key_dict = key_dict[elements[0]]
527
# a non-existant lookup.
532
key_dict = dicts.pop(-1)
533
# can't be empty or would not exist
534
item, value = key_dict.iteritems().next()
535
if type(value) == dict:
537
dicts.extend(key_dict.itervalues())
540
for value in key_dict.itervalues():
541
# each value is the key:value:node refs tuple
543
yield (self, ) + value
545
# the last thing looked up was a terminal element
546
yield (self, ) + key_dict
549
"""Return an estimate of the number of keys in this index.
551
For GraphIndex the estimate is exact.
553
if self._key_count is None:
554
# really this should just read the prefix
556
return self._key_count
558
def lookup_keys_via_location(self, location_keys):
559
"""Public interface for implementing bisection.
561
If _buffer_all has been called, then all the data for the index is in
562
memory, and this method should not be called, as it uses a separate
563
cache because it cannot pre-resolve all indices, which buffer_all does
566
:param location_keys: A list of location, key tuples.
567
:return: A list of (location_key, result) tuples as expected by
568
bzrlib.bisect_multi.bisect_multi_bytes.
570
# Possible improvements:
571
# - only bisect lookup each key once
572
# - sort the keys first, and use that to reduce the bisection window
574
# this progresses in three parts:
577
# attempt to answer the question from the now in memory data.
578
# build the readv request
579
# for each location, ask for 800 bytes - much more than rows we've seen
582
for location, key in location_keys:
583
# can we answer from cache?
584
# - if we know the answer - yes
585
index = self._parsed_key_index(key)
586
if (len(self._parsed_key_map) and
587
self._parsed_key_map[index][0] <= key and
588
(self._parsed_key_map[index][1] > key or
589
# end of the file has been parsed
590
self._parsed_byte_map[index][1] == self._size)):
591
# the key has been parsed, so no lookup is needed
593
# - if we have examined this part of the file already - yes
594
index = self._parsed_byte_index(location)
595
if (len(self._parsed_byte_map) and
596
self._parsed_byte_map[index][0] <= location and
597
self._parsed_byte_map[index][1] > location):
598
# the byte region has been parsed, so no read is needed.
601
if location + length > self._size:
602
length = self._size - location
603
# todo, trim out parsed locations.
605
readv_ranges.append((location, length))
606
# read the header if needed
607
if self._bisect_nodes is None:
608
readv_ranges.append((0, 200))
609
self._read_and_parse(readv_ranges)
611
# - figure out <, >, missing, present
612
# - result present references so we can return them.
614
# keys that we cannot answer until we resolve references
615
pending_references = []
616
pending_locations = set()
617
for location, key in location_keys:
618
# can we answer from cache?
619
index = self._parsed_key_index(key)
620
if (self._parsed_key_map[index][0] <= key and
621
(self._parsed_key_map[index][1] > key or
622
# end of the file has been parsed
623
self._parsed_byte_map[index][1] == self._size)):
624
# the key has been parsed, so no lookup is needed
625
if key in self._bisect_nodes:
626
if self.node_ref_lists:
627
# the references may not have been all parsed.
628
value, refs = self._bisect_nodes[key]
629
wanted_locations = []
630
for ref_list in refs:
632
if ref not in self._keys_by_offset:
633
wanted_locations.append(ref)
635
pending_locations.update(wanted_locations)
636
pending_references.append((location, key))
638
result.append(((location, key), (self, key,
639
value, self._resolve_references(refs))))
641
result.append(((location, key),
642
(self, key, self._bisect_nodes[key])))
644
result.append(((location, key), False))
646
# no, is the key above or below the probed location:
647
# get the range of the probed & parsed location
648
index = self._parsed_byte_index(location)
649
# if the key is below the start of the range, its below
650
if key < self._parsed_key_map[index][0]:
654
result.append(((location, key), direction))
656
# lookup data to resolve references
657
for location in pending_locations:
659
if location + length > self._size:
660
length = self._size - location
661
# TODO: trim out parsed locations (e.g. if the 800 is into the
662
# parsed region trim it, and dont use the ajust_for_latency
665
readv_ranges.append((location, length))
666
self._read_and_parse(readv_ranges)
667
for location, key in pending_references:
668
# answer key references we had to look-up-late.
669
index = self._parsed_key_index(key)
670
value, refs = self._bisect_nodes[key]
671
result.append(((location, key), (self, key,
672
value, self._resolve_references(refs))))
675
def _parse_header_from_bytes(self, bytes):
676
"""Parse the header from a region of bytes.
678
:param bytes: The data to parse.
679
:return: An offset, data tuple such as readv yields, for the unparsed
680
data. (which may length 0).
682
signature = bytes[0:len(self._signature())]
683
if not signature == self._signature():
684
raise errors.BadIndexFormatSignature(self._name, GraphIndex)
685
lines = bytes[len(self._signature()):].splitlines()
686
options_line = lines[0]
687
if not options_line.startswith(_OPTION_NODE_REFS):
688
raise errors.BadIndexOptions(self)
690
self.node_ref_lists = int(options_line[len(_OPTION_NODE_REFS):])
692
raise errors.BadIndexOptions(self)
693
options_line = lines[1]
694
if not options_line.startswith(_OPTION_KEY_ELEMENTS):
695
raise errors.BadIndexOptions(self)
697
self._key_length = int(options_line[len(_OPTION_KEY_ELEMENTS):])
699
raise errors.BadIndexOptions(self)
700
options_line = lines[2]
701
if not options_line.startswith(_OPTION_LEN):
702
raise errors.BadIndexOptions(self)
704
self._key_count = int(options_line[len(_OPTION_LEN):])
706
raise errors.BadIndexOptions(self)
707
# calculate the bytes we have processed
708
header_end = (len(signature) + len(lines[0]) + len(lines[1]) +
710
self._parsed_bytes(0, None, header_end, None)
711
# setup parsing state
712
self._expected_elements = 3 + self._key_length
713
# raw data keyed by offset
714
self._keys_by_offset = {}
715
# keys with the value and node references
716
self._bisect_nodes = {}
717
return header_end, bytes[header_end:]
719
def _parse_region(self, offset, data):
720
"""Parse node data returned from a readv operation.
722
:param offset: The byte offset the data starts at.
723
:param data: The data to parse.
727
end = offset + len(data)
728
index = self._parsed_byte_index(offset)
729
# default is to use all data
731
# trivial check for entirely parsed data:
732
if end < self._parsed_byte_map[index][1]:
734
# accomodate overlap with data before this.
735
if offset < self._parsed_byte_map[index][1]:
736
# overlaps the lower parsed region
737
# skip the parsed data
738
trim_start = self._parsed_byte_map[index][1] - offset
739
# don't trim the start for \n
740
start_adjacent = True
741
elif offset == self._parsed_byte_map[index][1]:
742
# abuts the lower parsed region
745
# do not trim anything
746
start_adjacent = True
748
# does not overlap the lower parsed region
751
# but trim the leading \n
752
start_adjacent = False
753
if end == self._size:
754
# lines up to the end of all data:
757
# do not strip to the last \n
759
elif index + 1 == len(self._parsed_byte_map):
760
# at the end of the parsed data
763
# but strip to the last \n
765
elif end == self._parsed_byte_map[index + 1][0]:
766
# buts up against the next parsed region
769
# do not strip to the last \n
771
elif end > self._parsed_byte_map[index + 1][0]:
772
# overlaps into the next parsed region
773
# only consider the unparsed data
774
trim_end = self._parsed_byte_map[index + 1][0] - offset
775
# do not strip to the last \n as we know its an entire record
778
# does not overlap into the next region
781
# but strip to the last \n
783
# now find bytes to discard if needed
784
if not start_adjacent:
785
# work around python bug in rfind
786
if trim_start is None:
787
trim_start = data.find('\n') + 1
789
trim_start = data.find('\n', trim_start) + 1
790
assert trim_start != 0, 'no \n was present'
791
# print 'removing start', offset, trim_start, repr(data[:trim_start])
793
# work around python bug in rfind
795
trim_end = data.rfind('\n') + 1
797
trim_end = data.rfind('\n', None, trim_end) + 1
798
assert trim_end != 0, 'no \n was present'
799
# print 'removing end', offset, trim_end, repr(data[trim_end:])
800
# adjust offset and data to the parseable data.
801
trimmed_data = data[trim_start:trim_end]
802
assert trimmed_data, 'read unneeded data'
805
# print "parsing", repr(trimmed_data)
806
# splitlines mangles the \r delimiters.. don't use it.
807
lines = trimmed_data.split('\n')
815
assert self._size == pos + 1, "%s %s" % (self._size, pos)
817
elements = line.split('\0')
818
if len(elements) != self._expected_elements:
819
raise errors.BadIndexData(self)
821
key = tuple(elements[:self._key_length])
822
if first_key is None:
824
absent, references, value = elements[-3:]
826
for ref_string in references.split('\t'):
827
ref_lists.append(tuple([
828
int(ref) for ref in ref_string.split('\r') if ref
830
ref_lists = tuple(ref_lists)
831
self._keys_by_offset[pos] = (key, absent, ref_lists, value)
832
pos += len(line) + 1 # +1 for the \n
835
if self.node_ref_lists:
836
node_value = (value, ref_lists)
839
self._bisect_nodes[key] = node_value
840
# print "parsed ", key
841
self._parsed_bytes(offset, first_key, offset + len(trimmed_data), key)
843
def _parsed_bytes(self, start, start_key, end, end_key):
844
"""Mark the bytes from start to end as parsed.
846
Calling self._parsed_bytes(1,2) will mark one byte (the one at offset
849
:param start: The start of the parsed region.
850
:param end: The end of the parsed region.
852
index = self._parsed_byte_index(start)
853
new_value = (start, end)
854
new_key = (start_key, end_key)
856
# first range parsed is always the beginning.
857
self._parsed_byte_map.insert(index, new_value)
858
self._parsed_key_map.insert(index, new_key)
862
# extend lower region
863
# extend higher region
864
# combine two regions
865
if (index + 1 < len(self._parsed_byte_map) and
866
self._parsed_byte_map[index][1] == start and
867
self._parsed_byte_map[index + 1][0] == end):
868
# combine two regions
869
self._parsed_byte_map[index] = (self._parsed_byte_map[index][0],
870
self._parsed_byte_map[index + 1][1])
871
self._parsed_key_map[index] = (self._parsed_key_map[index][0],
872
self._parsed_key_map[index + 1][1])
873
elif self._parsed_byte_map[index][1] == start:
874
# extend the lower entry
875
self._parsed_byte_map[index] = (
876
self._parsed_byte_map[index][0], end)
877
self._parsed_key_map[index] = (
878
self._parsed_key_map[index][0], end_key)
879
elif (index + 1 < len(self._parsed_byte_map) and
880
self._parsed_byte_map[index + 1][0] == end):
881
# extend the higher entry
882
self._parsed_byte_map[index + 1] = (
883
start, self._parsed_byte_map[index + 1][1])
884
self._parsed_key_map[index + 1] = (
885
start_key, self._parsed_key_map[index + 1][1])
888
self._parsed_byte_map.insert(index + 1, new_value)
889
self._parsed_key_map.insert(index + 1, new_key)
890
assert sorted(self._parsed_byte_map) == self._parsed_byte_map
891
assert sorted(self._parsed_key_map) == self._parsed_key_map
893
def _read_and_parse(self, readv_ranges):
894
"""Read the the ranges and parse the resulting data.
896
:param readv_ranges: A prepared readv range list.
899
readv_data = self._transport.readv(self._name, readv_ranges, True,
902
for offset, data in readv_data:
903
if self._bisect_nodes is None:
904
# this must be the start
906
offset, data = self._parse_header_from_bytes(data)
907
self._parse_region(offset, data)
908
# print offset, len(data), data
910
def _signature(self):
911
"""The file signature for this index type."""
915
"""Validate that everything in the index can be accessed."""
916
# iter_all validates completely at the moment, so just do that.
917
for node in self.iter_all_entries():
921
class CombinedGraphIndex(object):
922
"""A GraphIndex made up from smaller GraphIndices.
924
The backing indices must implement GraphIndex, and are presumed to be
927
Queries against the combined index will be made against the first index,
928
and then the second and so on. The order of index's can thus influence
929
performance significantly. For example, if one index is on local disk and a
930
second on a remote server, the local disk index should be before the other
934
def __init__(self, indices):
935
"""Create a CombinedGraphIndex backed by indices.
937
:param indices: An ordered list of indices to query for data.
939
self._indices = indices
943
self.__class__.__name__,
944
', '.join(map(repr, self._indices)))
946
def insert_index(self, pos, index):
947
"""Insert a new index in the list of indices to query.
949
:param pos: The position to insert the index.
950
:param index: The index to insert.
952
self._indices.insert(pos, index)
954
def iter_all_entries(self):
955
"""Iterate over all keys within the index
957
Duplicate keys across child indices are presumed to have the same
958
value and are only reported once.
960
:return: An iterable of (index, key, reference_lists, value).
961
There is no defined order for the result iteration - it will be in
962
the most efficient order for the index.
965
for index in self._indices:
966
for node in index.iter_all_entries():
967
if node[1] not in seen_keys:
969
seen_keys.add(node[1])
971
def iter_entries(self, keys):
972
"""Iterate over keys within the index.
974
Duplicate keys across child indices are presumed to have the same
975
value and are only reported once.
977
:param keys: An iterable providing the keys to be retrieved.
978
:return: An iterable of (index, key, reference_lists, value). There is no
979
defined order for the result iteration - it will be in the most
980
efficient order for the index.
983
for index in self._indices:
986
for node in index.iter_entries(keys):
990
def iter_entries_prefix(self, keys):
991
"""Iterate over keys within the index using prefix matching.
993
Duplicate keys across child indices are presumed to have the same
994
value and are only reported once.
996
Prefix matching is applied within the tuple of a key, not to within
997
the bytestring of each key element. e.g. if you have the keys ('foo',
998
'bar'), ('foobar', 'gam') and do a prefix search for ('foo', None) then
999
only the former key is returned.
1001
:param keys: An iterable providing the key prefixes to be retrieved.
1002
Each key prefix takes the form of a tuple the length of a key, but
1003
with the last N elements 'None' rather than a regular bytestring.
1004
The first element cannot be 'None'.
1005
:return: An iterable as per iter_all_entries, but restricted to the
1006
keys with a matching prefix to those supplied. No additional keys
1007
will be returned, and every match that is in the index will be
1014
for index in self._indices:
1015
for node in index.iter_entries_prefix(keys):
1016
if node[1] in seen_keys:
1018
seen_keys.add(node[1])
1021
def key_count(self):
1022
"""Return an estimate of the number of keys in this index.
1024
For CombinedGraphIndex this is approximated by the sum of the keys of
1025
the child indices. As child indices may have duplicate keys this can
1026
have a maximum error of the number of child indices * largest number of
1029
return sum((index.key_count() for index in self._indices), 0)
1032
"""Validate that everything in the index can be accessed."""
1033
for index in self._indices:
1037
class InMemoryGraphIndex(GraphIndexBuilder):
1038
"""A GraphIndex which operates entirely out of memory and is mutable.
1040
This is designed to allow the accumulation of GraphIndex entries during a
1041
single write operation, where the accumulated entries need to be immediately
1042
available - for example via a CombinedGraphIndex.
1045
def add_nodes(self, nodes):
1046
"""Add nodes to the index.
1048
:param nodes: An iterable of (key, node_refs, value) entries to add.
1050
if self.reference_lists:
1051
for (key, value, node_refs) in nodes:
1052
self.add_node(key, value, node_refs)
1054
for (key, value) in nodes:
1055
self.add_node(key, value)
1057
def iter_all_entries(self):
1058
"""Iterate over all keys within the index
1060
:return: An iterable of (index, key, reference_lists, value). There is no
1061
defined order for the result iteration - it will be in the most
1062
efficient order for the index (in this case dictionary hash order).
1064
if 'evil' in debug.debug_flags:
1065
trace.mutter_callsite(3,
1066
"iter_all_entries scales with size of history.")
1067
if self.reference_lists:
1068
for key, (absent, references, value) in self._nodes.iteritems():
1070
yield self, key, value, references
1072
for key, (absent, references, value) in self._nodes.iteritems():
1074
yield self, key, value
1076
def iter_entries(self, keys):
1077
"""Iterate over keys within the index.
1079
:param keys: An iterable providing the keys to be retrieved.
1080
:return: An iterable of (index, key, reference_lists, value). There is no
1081
defined order for the result iteration - it will be in the most
1082
efficient order for the index (keys iteration order in this case).
1085
if self.reference_lists:
1086
for key in keys.intersection(self._keys):
1087
node = self._nodes[key]
1089
yield self, key, node[2], node[1]
1091
for key in keys.intersection(self._keys):
1092
node = self._nodes[key]
1094
yield self, key, node[2]
1096
def iter_entries_prefix(self, keys):
1097
"""Iterate over keys within the index using prefix matching.
1099
Prefix matching is applied within the tuple of a key, not to within
1100
the bytestring of each key element. e.g. if you have the keys ('foo',
1101
'bar'), ('foobar', 'gam') and do a prefix search for ('foo', None) then
1102
only the former key is returned.
1104
:param keys: An iterable providing the key prefixes to be retrieved.
1105
Each key prefix takes the form of a tuple the length of a key, but
1106
with the last N elements 'None' rather than a regular bytestring.
1107
The first element cannot be 'None'.
1108
:return: An iterable as per iter_all_entries, but restricted to the
1109
keys with a matching prefix to those supplied. No additional keys
1110
will be returned, and every match that is in the index will be
1113
# XXX: To much duplication with the GraphIndex class; consider finding
1114
# a good place to pull out the actual common logic.
1118
if self._key_length == 1:
1122
raise errors.BadIndexKey(key)
1123
if len(key) != self._key_length:
1124
raise errors.BadIndexKey(key)
1125
node = self._nodes[key]
1128
if self.reference_lists:
1129
yield self, key, node[2], node[1]
1131
yield self, key, node[2]
1136
raise errors.BadIndexKey(key)
1137
if len(key) != self._key_length:
1138
raise errors.BadIndexKey(key)
1139
# find what it refers to:
1140
key_dict = self._nodes_by_key
1141
elements = list(key)
1142
# find the subdict to return
1144
while len(elements) and elements[0] is not None:
1145
key_dict = key_dict[elements[0]]
1148
# a non-existant lookup.
1153
key_dict = dicts.pop(-1)
1154
# can't be empty or would not exist
1155
item, value = key_dict.iteritems().next()
1156
if type(value) == dict:
1158
dicts.extend(key_dict.itervalues())
1161
for value in key_dict.itervalues():
1162
yield (self, ) + value
1164
yield (self, ) + key_dict
1166
def key_count(self):
1167
"""Return an estimate of the number of keys in this index.
1169
For InMemoryGraphIndex the estimate is exact.
1171
return len(self._keys)
1174
"""In memory index's have no known corruption at the moment."""
1177
class GraphIndexPrefixAdapter(object):
1178
"""An adapter between GraphIndex with different key lengths.
1180
Queries against this will emit queries against the adapted Graph with the
1181
prefix added, queries for all items use iter_entries_prefix. The returned
1182
nodes will have their keys and node references adjusted to remove the
1183
prefix. Finally, an add_nodes_callback can be supplied - when called the
1184
nodes and references being added will have prefix prepended.
1187
def __init__(self, adapted, prefix, missing_key_length,
1188
add_nodes_callback=None):
1189
"""Construct an adapter against adapted with prefix."""
1190
self.adapted = adapted
1191
self.prefix_key = prefix + (None,)*missing_key_length
1192
self.prefix = prefix
1193
self.prefix_len = len(prefix)
1194
self.add_nodes_callback = add_nodes_callback
1196
def add_nodes(self, nodes):
1197
"""Add nodes to the index.
1199
:param nodes: An iterable of (key, node_refs, value) entries to add.
1201
# save nodes in case its an iterator
1202
nodes = tuple(nodes)
1203
translated_nodes = []
1205
# Add prefix_key to each reference node_refs is a tuple of tuples,
1206
# so split it apart, and add prefix_key to the internal reference
1207
for (key, value, node_refs) in nodes:
1208
adjusted_references = (
1209
tuple(tuple(self.prefix + ref_node for ref_node in ref_list)
1210
for ref_list in node_refs))
1211
translated_nodes.append((self.prefix + key, value,
1212
adjusted_references))
1214
# XXX: TODO add an explicit interface for getting the reference list
1215
# status, to handle this bit of user-friendliness in the API more
1217
for (key, value) in nodes:
1218
translated_nodes.append((self.prefix + key, value))
1219
self.add_nodes_callback(translated_nodes)
1221
def add_node(self, key, value, references=()):
1222
"""Add a node to the index.
1224
:param key: The key. keys are non-empty tuples containing
1225
as many whitespace-free utf8 bytestrings as the key length
1226
defined for this index.
1227
:param references: An iterable of iterables of keys. Each is a
1228
reference to another key.
1229
:param value: The value to associate with the key. It may be any
1230
bytes as long as it does not contain \0 or \n.
1232
self.add_nodes(((key, value, references), ))
1234
def _strip_prefix(self, an_iter):
1235
"""Strip prefix data from nodes and return it."""
1236
for node in an_iter:
1238
if node[1][:self.prefix_len] != self.prefix:
1239
raise errors.BadIndexData(self)
1240
for ref_list in node[3]:
1241
for ref_node in ref_list:
1242
if ref_node[:self.prefix_len] != self.prefix:
1243
raise errors.BadIndexData(self)
1244
yield node[0], node[1][self.prefix_len:], node[2], (
1245
tuple(tuple(ref_node[self.prefix_len:] for ref_node in ref_list)
1246
for ref_list in node[3]))
1248
def iter_all_entries(self):
1249
"""Iterate over all keys within the index
1251
iter_all_entries is implemented against the adapted index using
1252
iter_entries_prefix.
1254
:return: An iterable of (index, key, reference_lists, value). There is no
1255
defined order for the result iteration - it will be in the most
1256
efficient order for the index (in this case dictionary hash order).
1258
return self._strip_prefix(self.adapted.iter_entries_prefix([self.prefix_key]))
1260
def iter_entries(self, keys):
1261
"""Iterate over keys within the index.
1263
:param keys: An iterable providing the keys to be retrieved.
1264
:return: An iterable of (key, reference_lists, value). There is no
1265
defined order for the result iteration - it will be in the most
1266
efficient order for the index (keys iteration order in this case).
1268
return self._strip_prefix(self.adapted.iter_entries(
1269
self.prefix + key for key in keys))
1271
def iter_entries_prefix(self, keys):
1272
"""Iterate over keys within the index using prefix matching.
1274
Prefix matching is applied within the tuple of a key, not to within
1275
the bytestring of each key element. e.g. if you have the keys ('foo',
1276
'bar'), ('foobar', 'gam') and do a prefix search for ('foo', None) then
1277
only the former key is returned.
1279
:param keys: An iterable providing the key prefixes to be retrieved.
1280
Each key prefix takes the form of a tuple the length of a key, but
1281
with the last N elements 'None' rather than a regular bytestring.
1282
The first element cannot be 'None'.
1283
:return: An iterable as per iter_all_entries, but restricted to the
1284
keys with a matching prefix to those supplied. No additional keys
1285
will be returned, and every match that is in the index will be
1288
return self._strip_prefix(self.adapted.iter_entries_prefix(
1289
self.prefix + key for key in keys))
1291
def key_count(self):
1292
"""Return an estimate of the number of keys in this index.
1294
For GraphIndexPrefixAdapter this is relatively expensive - key
1295
iteration with the prefix is done.
1297
return len(list(self.iter_all_entries()))
1300
"""Call the adapted's validate."""
1301
self.adapted.validate()
added
removed
bzrlib/index.py
