def test_varbytes_offsets():
values = u("alfa bravo charlie delta echo foxtrot golf hotel").split()
vlen = len(values)
# Without offsets:
col = columns.VarBytesColumn(allow_offsets=False)
schema = fields.Schema(name=fields.ID(sortable=col))
with TempIndex(schema) as ix:
with ix.writer() as w:
for i in xrange(5000):
w.add_document(name=values[i % vlen])
with ix.reader() as r:
cr = r.column_reader("name")
assert isinstance(cr, columns.TranslatingColumnReader)
assert not cr.raw_column().had_stored_offsets
for i in (10, 100, 1000, 3000):
assert cr[i] == values[i % vlen]
# With offsets
col = columns.VarBytesColumn(allow_offsets=True, write_offsets_cutoff=4096)
schema = fields.Schema(name=fields.ID(sortable=col))
with TempIndex(schema) as ix:
with ix.writer() as w:
for i in xrange(5000):
w.add_document(name=values[i % vlen])
with ix.reader() as r:
cr = r.column_reader("name")
assert isinstance(cr, columns.TranslatingColumnReader)
assert cr.raw_column().had_stored_offsets
for i in (10, 100, 1000, 3000):
assert cr[i] == values[i % vlen]
def test_multifacet():
schema = fields.Schema(tag=fields.ID(stored=True),
size=fields.ID(stored=True))
with TempIndex(schema, "multifacet") as ix:
w = ix.writer()
w.add_document(tag=u("alfa"), size=u("small"))
w.add_document(tag=u("bravo"), size=u("medium"))
w.add_document(tag=u("alfa"), size=u("large"))
w.add_document(tag=u("bravo"), size=u("small"))
w.add_document(tag=u("alfa"), size=u("medium"))
w.add_document(tag=u("bravo"), size=u("medium"))
w.commit()
correct = {
(u('bravo'), u('medium')): [1, 5],
(u('alfa'), u('large')): [2],
(u('alfa'), u('medium')): [4],
(u('alfa'), u('small')): [0],
(u('bravo'), u('small')): [3]
}
with ix.searcher() as s:
facet = sorting.MultiFacet(["tag", "size"])
r = s.search(query.Every(), groupedby={"tag/size": facet})
cats = r.groups(("tag/size"))
assert_equal(cats, correct)
def get_schema():
return fields.Schema(id=fields.ID(stored=True),
num=fields.NUMERIC(stored=True),
frac=fields.NUMERIC(float, stored=True),
tag=fields.ID(stored=True),
ev=fields.ID,
)
def test_update():
# Test update with multiple unique keys
SAMPLE_DOCS = [
{
"id": u("test1"),
"path": u("/test/1"),
"text": u("Hello")
},
{
"id": u("test2"),
"path": u("/test/2"),
"text": u("There")
},
{
"id": u("test3"),
"path": u("/test/3"),
"text": u("Reader")
},
]
schema = fields.Schema(id=fields.ID(unique=True, stored=True),
path=fields.ID(unique=True, stored=True),
text=fields.TEXT)
with TempIndex(schema, "update") as ix:
with ix.writer() as w:
for doc in SAMPLE_DOCS:
w.add_document(**doc)
with ix.writer() as w:
w.update_document(id=u("test2"),
path=u("test/1"),
text=u("Replacement"))
class Organization(fields.SchemaClass):
# numero_de_da : Numéro de la Déclaration d'Activité -
numero_de_da = fields.ID(stored=True, unique=True)
# form_total : Nombre de formateurs -
form_total = fields.NUMERIC(stored=True)
# da_siren : Numéro de SIREN de la structure -
da_siren = fields.ID(stored=True, unique=True)
# da_no_etab : Numéro d'établissement de la structure -
da_no_etab = fields.ID(stored=True)
# da_raison_sociale : Raison Sociale -
da_raison_sociale = fields.TEXT(stored=True,
analyzer=ngram_analyzer,
phrase=False)
# adr_rue_physique : Voie de l'adresse physique -
adr_rue_physique = fields.TEXT(stored=True)
# adr_rue_complement_physique : Complément de l'adresse physique -
adr_rue_complement_physique = fields.TEXT(stored=True)
# adr_code_postal_physique : Code postal de l'adresse physique -
adr_code_postal_physique = fields.ID(stored=True)
# adr_ville_physique : Ville de l'adresse physique -
adr_ville_physique = fields.TEXT(stored=True)
# adr_rue_postale : Voie de l'adresse postale -
adr_rue_postale = fields.TEXT(stored=True)
# adr_rue_complement_postale : Complément de l'adresse postale -
adr_rue_complement_postale = fields.TEXT(stored=True)
# adr_code_postal_postale : Code postal de l'adresse postale -
adr_code_postal_postale = fields.ID(stored=True)
# adr_ville_postale : Ville de l'adresse postale
adr_ville_postale = fields.TEXT(stored=True)
def server(username):
# 可以每个用户一个目录
WHOOSH_PATH = '/home/python/Learn/django/Haystack-Whoosh/whoosh_index/%s' % username
# 创建索引结构
WHOOSH_SCHEMA = fields.Schema(
id=fields.ID(stored=True),
user_id=fields.ID(stored=True),
title=fields.TEXT(stored=True, sortable=True, analyzer=analyser),
content=fields.TEXT(stored=True, sortable=True, analyzer=analyser),
)
if not os.path.exists(WHOOSH_PATH):
# os.mkdir(WHOOSH_PATH)
create_dir(WHOOSH_PATH)
ix = create_in(WHOOSH_PATH, schema=WHOOSH_SCHEMA,
indexname='content') # path 为索引创建的地址，indexname 为索引名称
ix = open_dir(WHOOSH_PATH, indexname='content')
# writter = ix.writer()
writter = whoosh_writter(ix)
writter.add_document(
id=str(1),
user_id="1",
title='分布式架构的前世今生...',
content='随着社会的发展，技术的进步，以前的大型机架构很显然由于高成本、难维护等原因渐渐地变得不再那么主流了，'
'替代它的就是当下最火的分布式架构，从大型机到分布式，经历了好几个阶段，我们弄明白各个阶段的架构，才能更好地理解和体会分布式架构的好处，'
'那么本文我们就来聊聊分布式架构的演进过程，希望能给大家带来眼前一亮的感觉。')
writter.add_document(
id=str(2),
user_id="1",
title='高并发的核心技术-幂等的实现方案',
content='我们发起一笔付款请求，应该只扣用户账户一次钱，当遇到网络重发或系统bug重发，也应该只扣一次钱；')
writter.commit()
class OffersSchema(fields.SchemaClass):
pk = fields.ID(unique=True, stored=True)
slug = fields.ID(stored=True)
name = fields.TEXT(stored=True)
wishes = fields.KEYWORD(commas=True)
target_group = fields.KEYWORD(commas=True)
organization = fields.TEXT(stored=True, sortable=True)
def test_more_like_this(model=classify.Bo2Model):
docs = [
u("alfa bravo charlie delta echo foxtrot golf"),
u("delta echo foxtrot golf hotel india juliet"),
u("echo foxtrot golf hotel india juliet kilo"),
u("foxtrot golf hotel india juliet kilo lima"),
u("golf hotel india juliet kilo lima mike"),
u("foxtrot golf hotel india alfa bravo charlie")
]
def _check(schema, **kwargs):
ix = RamStorage().create_index(schema)
with ix.writer() as w:
for i, text in enumerate(docs):
w.add_document(id=text_type(i + 1), text=text)
with ix.searcher() as s:
docnum = s.document_number(id=u("1"))
r = s.more_like(docnum, "text", model=model, **kwargs)
assert [hit["id"] for hit in r] == ["6", "2", "3"]
schema = fields.Schema(id=fields.ID(stored=True),
text=fields.TEXT(stored=True))
_check(schema)
ana = analysis.StandardAnalyzer()
schema = fields.Schema(id=fields.ID(stored=True),
text=fields.TEXT(analyzer=ana,
vector=formats.Frequency()))
_check(schema)
schema = fields.Schema(id=fields.ID(stored=True), text=fields.TEXT)
_check(schema, text=docs[0])
def test_finalweighting(self):
from whoosh.scoring import Weighting
schema = fields.Schema(id=fields.ID(stored=True),
summary=fields.TEXT,
n_comments=fields.ID(stored=True))
st = RamStorage()
ix = st.create_index(schema)
w = ix.writer()
w.add_document(id=u"1", summary=u"alfa bravo", n_comments=u"5")
w.add_document(id=u"2", summary=u"alfa", n_comments=u"12")
w.add_document(id=u"3", summary=u"bravo", n_comments=u"2")
w.add_document(id=u"4", summary=u"bravo bravo", n_comments=u"7")
w.commit()
class CommentWeighting(Weighting):
def score(self, *args, **kwargs):
return 0
def final(self, searcher, docnum, score):
ncomments = int(
searcher.stored_fields(docnum).get("n_comments"))
return ncomments
s = ix.searcher(weighting=CommentWeighting())
r = s.search(qparser.QueryParser("summary").parse("alfa OR bravo"))
ids = [fs["id"] for fs in r]
self.assertEqual(ids, ["2", "4", "1", "3"])
def test_weighting(self):
from whoosh.scoring import Weighting
schema = fields.Schema(id=fields.ID(stored=True),
n_comments=fields.ID(stored=True))
st = RamStorage()
ix = st.create_index(schema)
w = ix.writer()
w.add_document(id=u"1", n_comments=u"5")
w.add_document(id=u"2", n_comments=u"12")
w.add_document(id=u"3", n_comments=u"2")
w.add_document(id=u"4", n_comments=u"7")
w.commit()
class CommentWeighting(Weighting):
def score(self, searcher, fieldnum, text, docnum, weight, QTF=1):
ncomments = int(
searcher.stored_fields(docnum).get("n_comments", "0"))
return ncomments
s = ix.searcher(weighting=CommentWeighting())
r = s.search(qparser.QueryParser("id").parse("[1 TO 4]"))
ids = [fs["id"] for fs in r]
self.assertEqual(ids, ["2", "4", "1", "3"])
def test_sort_filter():
schema = fields.Schema(group=fields.ID(stored=True),
key=fields.ID(stored=True))
groups = u("alfa bravo charlie").split()
keys = u("abcdefghijklmnopqrstuvwxyz")
source = []
for i in xrange(100):
key = keys[i % len(keys)]
group = groups[i % len(groups)]
source.append({"key": key, "group": group})
source.sort(key=lambda x: (x["key"], x["group"]))
sample = list(source)
random.shuffle(sample)
with TempIndex(schema, "sortfilter") as ix:
w = ix.writer()
for i, fs in enumerate(sample):
w.add_document(**fs)
i += 1
if not i % 26:
w.commit(merge=False)
w = ix.writer()
w.commit()
fq = query.Term("group", u("bravo"))
with ix.searcher() as s:
r = s.search(query.Every(),
sortedby=("key", "group"),
filter=fq,
limit=20)
assert_equal([h.fields() for h in r],
[d for d in source if d["group"] == "bravo"][:20])
fq = query.Term("group", u("bravo"))
r = s.search(query.Every(),
sortedby=("key", "group"),
filter=fq,
limit=None)
assert_equal([h.fields() for h in r],
[d for d in source if d["group"] == "bravo"])
ix.optimize()
with ix.searcher() as s:
r = s.search(query.Every(),
sortedby=("key", "group"),
filter=fq,
limit=20)
assert_equal([h.fields() for h in r],
[d for d in source if d["group"] == "bravo"][:20])
fq = query.Term("group", u("bravo"))
r = s.search(query.Every(),
sortedby=("key", "group"),
filter=fq,
limit=None)
assert_equal([h.fields() for h in r],
[d for d in source if d["group"] == "bravo"])
def test_update(self):
# Test update with multiple unique keys
SAMPLE_DOCS = [{"id": u"test1", "path": u"/test/1", "text": u"Hello"},
{"id": u"test2", "path": u"/test/2", "text": u"There"},
{"id": u"test3", "path": u"/test/3", "text": u"Reader"},
]
schema = fields.Schema(id=fields.ID(unique=True, stored=True),
path=fields.ID(unique=True, stored=True),
text=fields.TEXT)
ix = self.make_index("testindex", schema, "test_update")
try:
writer = ix.writer()
try:
for doc in SAMPLE_DOCS:
writer.add_document(**doc)
writer.commit()
except:
writer.cancel()
raise
writer = ix.writer()
try:
writer.update_document(id=u"test2", path=u"test/1", text=u"Replacement")
writer.commit()
except:
writer.cancel()
raise
finally:
ix.close()
self.destroy_index("testindex")
def test_simple_stored():
schema = fields.Schema(a=fields.ID(stored=True), b=fields.ID(stored=False))
ix = RamStorage().create_index(schema)
with ix.writer() as w:
w.add_document(a=u("alfa"), b=u("bravo"))
with ix.searcher() as s:
sf = s.stored_fields(0)
assert sf == {"a": "alfa"}
def whoosh_schema(self):
ana = analysis.StemmingAnalyzer(maxsize=40, cachesize=None)
storebody = self.options.storebody
schema = fields.Schema(body=fields.TEXT(analyzer=ana, stored=storebody),
filepos=fields.STORED,
date=fields.ID(stored=True),
frm=fields.ID(stored=True),
to=fields.IDLIST(stored=True),
subject=fields.TEXT(stored=True),
cc=fields.IDLIST,
bcc=fields.IDLIST)
return schema
def _mk_schema(self, dsinfo):
from whoosh import fields as wf
from whoosh.analysis import StandardAnalyzer
# TODO support some customizable mapping to homogenize some metadata fields
# onto a given set of index keys
self.schema = wf.Schema(id=wf.ID,
path=wf.ID(stored=True),
type=wf.ID(stored=True),
parentds=wf.ID(stored=True),
meta=wf.TEXT(
stored=False,
analyzer=StandardAnalyzer(minsize=2)))
def get_schema():
"""
This method creates the whoosh schema. It is only needed when the search
index is build. After this, the schema is saved and loaded with the index.
When the schema is changed, then the index has to be recreated or the index
has to be altert. See:
https://pythonhosted.org/Whoosh/schema.html#modifying-the-schema-after-indexing
"""
return fields.Schema(id=fields.ID(stored=True),
collection=fields.ID(stored=True),
id_collection=fields.ID(unique=True),
content=fields.TEXT)
def test_add_field():
schema = fields.Schema(a=fields.TEXT)
with TempIndex(schema, "addfield") as ix:
with ix.writer() as w:
w.add_document(a=u"alfa bravo charlie")
with ix.writer() as w:
w.add_field("b", fields.ID(stored=True))
w.add_field("c*", fields.ID(stored=True), glob=True)
w.add_document(a=u"delta echo foxtrot", b=u"india", cat=u"juliet")
with ix.searcher() as s:
fs = s.document(b=u"india")
assert fs == {"b": "india", "cat": "juliet"}
def project_schema(self):
return fields.Schema(
path=fields.ID(stored=True, unique=True),
name=fields.ID(stored=True),
user=fields.ID(stored=True),
index=fields.ID(stored=True),
classifiers=fields.KEYWORD(commas=True, scorable=True),
keywords=fields.KEYWORD(stored=True, commas=False, scorable=True),
version=fields.STORED(),
doc_version=fields.STORED(),
type=fields.ID(stored=True),
text_path=fields.STORED(),
text_title=fields.STORED(),
text=fields.TEXT(analyzer=NgramWordAnalyzer(), stored=False, phrase=False))
def open_index():
from whoosh import index, fields as f
if os.path.isdir(app.config['WHOOSH_INDEX']):
return index.open_dir(app.config['WHOOSH_INDEX'])
os.mkdir(app.config['WHOOSH_INDEX'])
analyzer = analysis.StemmingAnalyzer() | analysis.CharsetFilter(accent_map)
schema = f.Schema(url=f.ID(stored=True, unique=True),
id=f.ID(stored=True),
title=f.TEXT(stored=True,
field_boost=2.0,
analyzer=analyzer),
type=f.ID(stored=True),
keywords=f.KEYWORD(commas=True),
content=f.TEXT(analyzer=analyzer))
return index.create_in(app.config['WHOOSH_INDEX'], schema)
def test_update2():
schema = fields.Schema(key=fields.ID(unique=True, stored=True),
p=fields.ID(stored=True))
with TempIndex(schema, "update2") as ix:
nums = list(range(100))
random.shuffle(nums)
for i, n in enumerate(nums):
w = ix.writer()
w.update_document(key=text_type(n % 10), p=text_type(i))
w.commit()
with ix.searcher() as s:
results = [d["key"] for d in s.all_stored_fields()]
results.sort()
assert_equal(results, ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"])
def test_update2():
schema = fields.Schema(key=fields.ID(unique=True, stored=True),
p=fields.ID(stored=True))
with TempIndex(schema, "update2") as ix:
nums = list(range(21))
random.shuffle(nums)
for i, n in enumerate(nums):
w = ix.writer()
w.update_document(key=text_type(n % 10), p=text_type(i))
w.commit()
with ix.searcher() as s:
results = [d["key"] for _, d in s.iter_docs()]
results = " ".join(sorted(results))
assert results == "0 1 2 3 4 5 6 7 8 9"
def test_update():
schema = fields.Schema(id=fields.ID(unique=True, stored=True),
text=fields.ID(stored=True))
ix = RamIndex(schema)
for word in u("alfa bravo charlie delta").split():
ix.update_document(id=word[0], text=word)
for word in u("apple burrito cat dollhouse").split():
ix.update_document(id=word[0], text=word)
assert ix.has_deletions()
assert_equal(ix.deleted, set([0, 1, 2, 3]))
assert_equal(ix.doc_count(), 4)
assert_equal([(d["id"], d["text"]) for d in ix.all_stored_fields()],
[("a", "apple"), ("b", "burrito"), ("c", "cat"),
("d", "dollhouse")])
def test_parse_fieldname_underscores():
s = fields.Schema(my_name=fields.ID(stored=True), my_value=fields.TEXT)
qp = default.QueryParser("my_value", schema=s)
q = qp.parse(u("my_name:Green"))
assert q.__class__ == query.Term
assert q.fieldname == "my_name"
assert q.text == "Green"
def test_add_sortable():
st = RamStorage()
schema = fields.Schema(chapter=fields.ID(stored=True), price=fields.NUMERIC)
ix = st.create_index(schema)
with ix.writer() as w:
w.add_document(chapter=u("alfa"), price=100)
w.add_document(chapter=u("bravo"), price=200)
w.add_document(chapter=u("charlie"), price=300)
w.add_document(chapter=u("delta"), price=400)
with ix.writer() as w:
w.add_document(chapter=u("bravo"), price=500)
w.add_document(chapter=u("alfa"), price=600)
w.add_document(chapter=u("delta"), price=100)
w.add_document(chapter=u("charlie"), price=200)
w.merge = False
with ix.reader() as r:
assert not r.has_column("chapter")
assert not r.has_column("price")
with ix.writer() as w:
sorting.add_sortable(w, "chapter", sorting.StoredFieldFacet("chapter"))
sorting.add_sortable(w, "price", sorting.FieldFacet("price"))
w.schema.test = 100
with ix.reader() as r:
assert r.has_column("chapter")
assert r.has_column("price")
chapr = r.column_reader("chapter")
pricer = r.column_reader("price")
assert chapr[0] == "alfa"
assert pricer[0] == 100
def test_removefield():
schema = fields.Schema(id=fields.ID(stored=True),
content=fields.TEXT,
city=fields.KEYWORD(stored=True))
with TempIndex(schema, "removefield") as ix:
w = ix.writer()
w.add_document(id=u("b"), content=u("bravo"), city=u("baghdad"))
w.add_document(id=u("c"), content=u("charlie"), city=u("cairo"))
w.add_document(id=u("d"), content=u("delta"), city=u("dakar"))
w.commit()
with ix.searcher() as s:
assert s.document(id=u("c")) == {"id": "c", "city": "cairo"}
w = ix.writer()
w.remove_field("content")
w.remove_field("city")
w.commit()
ixschema = ix._current_schema()
assert ixschema.names() == ["id"]
assert ixschema.stored_names() == ["id"]
with ix.searcher() as s:
assert ("content", b("charlie")) not in s.reader()
assert s.document(id=u("c")) == {"id": u("c")}
def test_boolean():
schema = fields.Schema(id=fields.ID(stored=True),
done=fields.BOOLEAN(stored=True))
ix = RamStorage().create_index(schema)
w = ix.writer()
w.add_document(id=u("a"), done=True)
w.add_document(id=u("b"), done=False)
w.add_document(id=u("c"), done=True)
w.add_document(id=u("d"), done=False)
w.add_document(id=u("e"), done=True)
w.commit()
with ix.searcher() as s:
qp = qparser.QueryParser("id", schema)
r = s.search(qp.parse("done:true"))
assert sorted([d["id"] for d in r]) == ["a", "c", "e"]
assert all(d["done"] for d in r)
r = s.search(qp.parse("done:yes"))
assert sorted([d["id"] for d in r]) == ["a", "c", "e"]
assert all(d["done"] for d in r)
q = qp.parse("done:false")
assert q.__class__ == query.Term
assert q.text is False
assert schema["done"].to_bytes(False) == b("f")
r = s.search(q)
assert sorted([d["id"] for d in r]) == ["b", "d"]
assert not any(d["done"] for d in r)
r = s.search(qp.parse("done:no"))
assert sorted([d["id"] for d in r]) == ["b", "d"]
assert not any(d["done"] for d in r)
def test_datetime():
dtf = fields.DATETIME(stored=True)
schema = fields.Schema(id=fields.ID(stored=True), date=dtf)
st = RamStorage()
ix = st.create_index(schema)
w = ix.writer()
for month in xrange(1, 12):
for day in xrange(1, 28):
w.add_document(id=u("%s-%s") % (month, day),
date=datetime(2010, month, day, 14, 0, 0))
w.commit()
with ix.searcher() as s:
qp = qparser.QueryParser("id", schema)
r = s.search(qp.parse("date:20100523"))
assert len(r) == 1
assert r[0]["id"] == "5-23"
assert r[0]["date"].__class__ is datetime
assert r[0]["date"].month == 5
assert r[0]["date"].day == 23
r = s.search(qp.parse("date:'2010 02'"))
assert len(r) == 27
q = qp.parse(u("date:[2010-05 to 2010-08]"))
startdt = datetime(2010, 5, 1, 0, 0, 0, 0)
enddt = datetime(2010, 8, 31, 23, 59, 59, 999999)
assert q.__class__ is query.NumericRange
assert q.start == times.datetime_to_long(startdt)
assert q.end == times.datetime_to_long(enddt)
def test_decimal_numeric():
from decimal import Decimal
f = fields.NUMERIC(int, decimal_places=4)
schema = fields.Schema(id=fields.ID(stored=True), deci=f)
ix = RamStorage().create_index(schema)
# assert f.from_text(f.to_text(Decimal("123.56"))), Decimal("123.56"))
w = ix.writer()
w.add_document(id=u("a"), deci=Decimal("123.56"))
w.add_document(id=u("b"), deci=Decimal("0.536255"))
w.add_document(id=u("c"), deci=Decimal("2.5255"))
w.add_document(id=u("d"), deci=Decimal("58"))
w.commit()
with ix.searcher() as s:
qp = qparser.QueryParser("deci", schema)
q = qp.parse(u("123.56"))
r = s.search(q)
assert len(r) == 1
assert r[0]["id"] == "a"
r = s.search(qp.parse(u("0.536255")))
assert len(r) == 1
assert r[0]["id"] == "b"
def test_numeric():
schema = fields.Schema(id=fields.ID(stored=True),
integer=fields.NUMERIC(int),
floating=fields.NUMERIC(float))
ix = RamStorage().create_index(schema)
w = ix.writer()
w.add_document(id=u("a"), integer=5820, floating=1.2)
w.add_document(id=u("b"), integer=22, floating=2.3)
w.add_document(id=u("c"), integer=78, floating=3.4)
w.add_document(id=u("d"), integer=13, floating=4.5)
w.add_document(id=u("e"), integer=9, floating=5.6)
w.commit()
with ix.searcher() as s:
qp = qparser.QueryParser("integer", schema)
q = qp.parse(u("5820"))
r = s.search(q)
assert len(r) == 1
assert r[0]["id"] == "a"
with ix.searcher() as s:
r = s.search(qp.parse("floating:4.5"))
assert len(r) == 1
assert r[0]["id"] == "d"
q = qp.parse("integer:*")
assert q.__class__ == query.Every
assert q.field() == "integer"
q = qp.parse("integer:5?6")
assert q == query.NullQuery
def test_globfield_length_merge():
# Issue 343
schema = fields.Schema(title=fields.TEXT(stored=True),
path=fields.ID(stored=True))
schema.add("*_text", fields.TEXT, glob=True)
with TempIndex(schema, "globlenmerge") as ix:
with ix.writer() as w:
w.add_document(
title=u("First document"),
path=u("/a"),
content_text=u("This is the first document we've added!"))
with ix.writer() as w:
w.add_document(
title=u("Second document"),
path=u("/b"),
content_text=u(
"The second document is even more interesting!"))
with ix.searcher() as s:
docnum = s.document_number(path="/a")
assert s.doc_field_length(docnum, "content_text") is not None
qp = qparser.QueryParser("content", schema)
q = qp.parse("content_text:document")
r = s.search(q)
paths = sorted(hit["path"] for hit in r)
assert paths == ["/a", "/b"]
