def __init__(self, storage, schema, segment):
self.storage = storage
self.schema = schema
self.segment = segment
if hasattr(self.segment, "uuid"):
self.uuid_string = str(self.segment.uuid)
else:
import uuid
self.uuid_string = str(uuid.uuid4())
# Term index
tf = storage.open_file(segment.termsindex_filename)
self.termsindex = TermIndexReader(tf)
# Term vector index, and vector postings: lazy load
self.vectorindex = None
self.vpostfile = None
# Stored fields file
sf = storage.open_file(segment.storedfields_filename, mapped=False)
self.storedfields = StoredFieldReader(sf)
# Field length file
self.fieldlengths = None
if self.schema.has_scorable_fields():
flf = storage.open_file(segment.fieldlengths_filename)
self.fieldlengths = LengthReader(flf, segment.doc_count_all())
# Copy info from underlying segment
self._has_deletions = segment.has_deletions()
self._doc_count = segment.doc_count()
# Postings file
self.postfile = self.storage.open_file(segment.termposts_filename,
mapped=False)
# Dawg file
self.dawg = None
if any(field.spelling for field in self.schema):
fname = segment.dawg_filename
if self.storage.file_exists(fname):
dawgfile = self.storage.open_file(fname, mapped=False)
self.dawg = DiskNode.load(dawgfile, expand=False)
self.dc = segment.doc_count_all()
assert self.dc == self.storedfields.length
self.set_caching_policy()
self.is_closed = False
self._sync_lock = Lock()
def test_termkey():
with TempStorage("termkey") as st:
tw = TermIndexWriter(st.create_file("test.trm"))
tw.add(("alfa", u("bravo")), FileTermInfo(1.0, 3))
tw.add(("alfa", u('\xc3\xa6\xc3\xaf\xc5\ufffd\xc3\xba')),
FileTermInfo(4.0, 6))
tw.add(("text", u('\xe6\u2014\xa5\xe6\u0153\xac\xe8\xaa\u017e')),
FileTermInfo(7.0, 9))
tw.close()
tr = TermIndexReader(st.open_file("test.trm"))
assert ("alfa", u("bravo")) in tr
assert ("alfa", u('\xc3\xa6\xc3\xaf\xc5\ufffd\xc3\xba')) in tr
assert ("text", u('\xe6\u2014\xa5\xe6\u0153\xac\xe8\xaa\u017e')) in tr
tr.close()
def test_termindex():
terms = [("a", "alfa"), ("a", "bravo"), ("a", "charlie"), ("a", "delta"),
("b", "able"), ("b", "baker"), ("b", "dog"), ("b", "easy")]
st = RamStorage()
tw = TermIndexWriter(st.create_file("test.trm"))
for i, t in enumerate(terms):
tw.add(t, FileTermInfo(1.0, i))
tw.close()
tr = TermIndexReader(st.open_file("test.trm"))
for i, (t1, t2) in enumerate(zip(tr.keys(), terms)):
assert_equal(t1, t2)
ti = tr.get(t1)
assert_equal(ti.weight(), 1.0)
assert_equal(ti.doc_frequency(), i)
def __init__(self, storage, schema, segment):
self.storage = storage
self.schema = schema
self.segment = segment
if hasattr(self.segment, "uuid"):
self.uuid_string = str(self.segment.uuid)
else:
import uuid
self.uuid_string = str(uuid.uuid4())
# Term index
tf = storage.open_file(segment.termsindex_filename)
self.termsindex = TermIndexReader(tf)
# Term postings file, vector index, and vector postings: lazy load
self.postfile = None
self.vectorindex = None
self.vpostfile = None
# Stored fields file
sf = storage.open_file(segment.storedfields_filename, mapped=False)
self.storedfields = StoredFieldReader(sf)
# Field length file
self.fieldlengths = None
if self.schema.has_scorable_fields():
flf = storage.open_file(segment.fieldlengths_filename)
self.fieldlengths = LengthReader(flf, segment.doc_count_all())
# Copy methods from underlying segment
self.has_deletions = segment.has_deletions
self.is_deleted = segment.is_deleted
self.doc_count = segment.doc_count
# Postings file
self.postfile = self.storage.open_file(segment.termposts_filename,
mapped=False)
self.dc = segment.doc_count_all()
assert self.dc == self.storedfields.length
self.set_caching_policy()
self.is_closed = False
self._sync_lock = Lock()
def test_read_inline():
schema = fields.Schema(a=fields.TEXT)
assert schema["a"].scorable
with TempIndex(schema, "readinline") as ix:
w = ix.writer()
w.add_document(a=u("alfa"))
w.add_document(a=u("bravo"))
w.add_document(a=u("charlie"))
w.commit()
tr = TermIndexReader(ix.storage.open_file("_readinline_1.trm"))
for i, (_, terminfo) in enumerate(tr.items()):
assert_equal(terminfo.postings[0], (i, ))
assert_equal(terminfo.postings[1], (1.0, ))
tr.close()
with ix.reader() as r:
pr = r.postings("a", "bravo")
assert_equal(pr.id(), 1)
def test_random_termkeys():
def random_fieldname():
return "".join(chr(random.randint(65, 90)) for _ in xrange(1, 20))
def random_token():
return "".join(
unichr(random.randint(0, 0xd7ff)) for _ in xrange(1, 20))
domain = sorted([(random_fieldname(), random_token())
for _ in xrange(1000)])
st = RamStorage()
tw = TermIndexWriter(st.create_file("test.trm"))
for term in domain:
tw.add(term, FileTermInfo(1.0, 1))
tw.close()
tr = TermIndexReader(st.open_file("test.trm"))
for term in domain:
assert term in tr
