void setUpDirs(CuTest *tc, Directory * dir, Directory * aux) {
IndexWriter4Test * writer = NULL;
WhitespaceAnalyzer analyzer;
writer = newWriter(dir, &analyzer, true);
writer->setMaxBufferedDocs(1000);
// add 1000 documents in 1 segment
addDocs(writer, 1000);
assertEquals(1000, writer->docCount());
assertEquals(1, writer->getSegmentCount());
writer->close();
_CLLDELETE(writer);
writer = newWriter(aux, &analyzer, true);
writer->setUseCompoundFile(false); // use one without a compound file
writer->setMaxBufferedDocs(100);
writer->setMergeFactor(10);
// add 30 documents in 3 segments
for (int i = 0; i < 3; i++) {
addDocs(writer, 10);
writer->close();
_CLLDELETE(writer);
writer = newWriter(aux, &analyzer, false);
writer->setUseCompoundFile(false); // use one without a compound file
writer->setMaxBufferedDocs(100);
writer->setMergeFactor(10);
}
assertEquals(30, writer->docCount());
assertEquals(3, writer->getSegmentCount());
writer->close();
_CLLDELETE(writer);
}
// case 3: tail segments, invariants hold, copy, invariants hold
void testNoMergeAfterCopy(CuTest * tc) {
// main directory
Directory * dir = _CLNEW RAMDirectory();
// auxiliary directory
Directory * aux = _CLNEW RAMDirectory();
WhitespaceAnalyzer an;
setUpDirs(tc, dir, aux);
IndexWriter4Test * writer = newWriter(dir, &an, false);
writer->setMaxBufferedDocs(10);
writer->setMergeFactor(4);
ValueArray<Directory*> dirs(2);
dirs[0] = aux;
dirs[1] = aux;
writer->addIndexesNoOptimize(dirs);
assertEquals(1060, writer->docCount());
assertEquals(1000, writer->getDocCount(0));
writer->close();
_CLLDELETE(writer);
// make sure the index is correct
verifyNumDocs(tc, dir, 1060);
dir->close();
_CLLDELETE(dir);
aux->close();
_CLLDELETE(aux);
}
// BK> all test functions are the same except RAMDirectory constructor, so shared code moved here
void checkDir(CuTest *tc, MockRAMDirectory * ramDir) {
// Check size
CuAssertTrue(tc, ramDir->sizeInBytes == ramDir->getRecomputedSizeInBytes(), _T("RAMDir size"));
// open reader to test document count
IndexReader * reader = IndexReader::open(ramDir);
CuAssertEquals(tc, docsToAdd, reader->numDocs(), _T("document count"));
// open search to check if all doc's are there
IndexSearcher * searcher = _CLNEW IndexSearcher(reader);
// search for all documents
Document doc;
for (int i = 0; i < docsToAdd; i++) {
searcher->doc(i, doc);
CuAssertTrue(tc, doc.getField(_T("content")) != NULL, _T("content is NULL"));
}
// cleanup
reader->close();
searcher->close();
_CLLDELETE(reader);
_CLLDELETE(searcher);
}
// LUCENE-1270
void testHangOnClose(CuTest * tc) {
WhitespaceAnalyzer an;
MockRAMDirectory * dir = _CLNEW MockRAMDirectory();
dir->setRandomIOExceptionRate(0.0, 0);
IndexWriter4Test * writer = _CLNEW IndexWriter4Test(dir, false, &an, true);
writer->setMergePolicy(_CLNEW LogByteSizeMergePolicy());
writer->setMaxBufferedDocs(5);
writer->setUseCompoundFile(false);
writer->setMergeFactor(100);
Document doc;
doc.add(* _CLNEW Field(_T("content"), _T("aaa bbb ccc ddd eee fff ggg hhh iii"),
Field::STORE_YES | Field::INDEX_TOKENIZED | Field::TERMVECTOR_WITH_POSITIONS_OFFSETS));
for(int i=0;i<60;i++)
writer->addDocument(&doc);
writer->setMaxBufferedDocs(200);
Document doc2;
doc2.add(* _CLNEW Field(_T("content"), _T("aaa bbb ccc ddd eee fff ggg hhh iii"),
Field::STORE_YES | Field::INDEX_NO));
doc2.add(* _CLNEW Field(_T("content"), _T("aaa bbb ccc ddd eee fff ggg hhh iii"),
Field::STORE_YES | Field::INDEX_NO));
doc2.add(* _CLNEW Field(_T("content"), _T("aaa bbb ccc ddd eee fff ggg hhh iii"),
Field::STORE_YES | Field::INDEX_NO));
doc2.add(* _CLNEW Field(_T("content"), _T("aaa bbb ccc ddd eee fff ggg hhh iii"),
Field::STORE_YES | Field::INDEX_NO));
for(int i=0;i<10;i++)
writer->addDocument(&doc2);
writer->close();
_CLLDELETE(writer);
MockRAMDirectory * dir2 = _CLNEW MockRAMDirectory();
dir2->setRandomIOExceptionRate(0.0, 0);
writer = _CLNEW IndexWriter4Test(dir2, false, &an, true);
LogByteSizeMergePolicy * lmp = _CLNEW LogByteSizeMergePolicy();
lmp->setMinMergeMB(0.0001);
writer->setMergePolicy(lmp);
writer->setMergeFactor(4);
writer->setUseCompoundFile(false);
writer->setMergeScheduler(_CLNEW SerialMergeScheduler());
ValueArray<Directory*> dirs(1);
dirs[0] = dir;
writer->addIndexesNoOptimize(dirs);
writer->close();
_CLLDELETE(writer);
dir->close();
_CLLDELETE(dir);
dir2->close();
_CLLDELETE(dir2);
}
void testBasics()
{
Query * q1 = csrq( _T( "data" ), _T( "1" ), _T( "6" ), true, true );
Query * q2 = csrq( _T( "data" ), _T( "A" ) ,_T( "Z" ), true, true );
QueryUtils::check( tc, q1 );
QueryUtils::check( tc, q2 );
QueryUtils::checkUnequal( tc, q1, q2 );
_CLLDELETE( q2 );
_CLLDELETE( q1 );
}
void testEndThreadException(CuTest *tc) {
const int MAX_DOCS=1500;
RAMDirectory ram;
WhitespaceAnalyzer an;
IndexWriter* writer = _CLNEW IndexWriter(&ram, &an, true);
// add some documents
Document doc;
for (int i = 0; i < MAX_DOCS; i++) {
TCHAR * tmp = English::IntToEnglish(i);
doc.add(* new Field(_T("content"), tmp, Field::STORE_YES | Field::INDEX_UNTOKENIZED));
writer->addDocument(&doc);
doc.clear();
_CLDELETE_ARRAY( tmp );
}
CuAssertEquals(tc, MAX_DOCS, writer->docCount());
writer->close();
_CLLDELETE(writer);
// this sequence is OK: delete searcher after search thread finish
{
IndexSearcher * searcher = _CLNEW IndexSearcher(&ram);
_LUCENE_THREADID_TYPE thread = _LUCENE_THREAD_CREATE(&searchDocs, searcher);
SCOPED_LOCK_MUTEX(searchMutex);
CONDITION_WAIT(searchMutex, searchCondition);
// _LUCENE_SLEEP(9999); //make sure that deleteMutex is being waited on...
CONDITION_NOTIFYALL(deleteCondition);
_LUCENE_THREAD_JOIN(thread);
searcher->close();
_CLLDELETE(searcher);
}
// this produces memory exception: delete searcher after search finish but before thread finish
{
IndexSearcher * searcher = _CLNEW IndexSearcher(&ram);
_LUCENE_THREADID_TYPE thread = _LUCENE_THREAD_CREATE(&searchDocs, searcher);
SCOPED_LOCK_MUTEX(searchMutex);
CONDITION_WAIT(searchMutex, searchCondition);
searcher->close();
_CLLDELETE(searcher);
CONDITION_NOTIFYALL(deleteCondition);
_LUCENE_THREAD_JOIN(thread);
}
ram.close();
}
static void verifyTermDocs(CuTest *tc, Directory * dir, Term * term, int numDocs) {
IndexReader * reader = IndexReader::open(dir);
TermDocs * termDocs = reader->termDocs(term);
int count = 0;
while (termDocs->next())
count++;
assertEquals(numDocs, count);
termDocs->close();
_CLLDELETE(termDocs);
reader->close();
_CLLDELETE(reader);
}
Query* FuzzyQuery::rewrite(IndexReader* reader) {
FilteredTermEnum* enumerator = getEnum(reader);
const size_t maxClauseCount = BooleanQuery::getMaxClauseCount();
ScoreTermQueue* stQueue = _CLNEW ScoreTermQueue(maxClauseCount);
ScoreTerm* reusableST = NULL;
try {
do {
float_t score = 0.0f;
Term* t = enumerator->term();
if (t != NULL) {
score = enumerator->difference();
if (reusableST == NULL) {
reusableST = _CLNEW ScoreTerm(t, score);
} else if (score >= reusableST->score) {
// reusableST holds the last "rejected" entry, so, if
// this new score is not better than that, there's no
// need to try inserting it
reusableST->score = score;
reusableST->term = t;
} else {
continue;
}
reusableST = stQueue->insertWithOverflow(reusableST);
}
} while (enumerator->next());
} _CLFINALLY({
enumerator->close();
_CLLDELETE(enumerator);
//_CLLDELETE(reusableST);
});
HitDoc::~HitDoc(){
//Func - Destructor
//Pre - true
//Post - The instance has been destroyed
_CLLDELETE(doc);
}
void TestBasics::testNpeInSpanNearInSpanFirstInSpanNot()
{
int32_t expectedDocs[] = {40,41,42,43,44,45,46,47,48,49};
SpanQuery * clauses[ 2 ];
int32_t n = 5;
Term * hun = _CLNEW Term( _T( "field" ), _T( "hundred" ));
Term * term40 = _CLNEW Term( _T( "field" ), _T( "forty" ));
SpanTermQuery * termQry40 = _CLNEW SpanTermQuery( term40 );
clauses[ 0 ] = _CLNEW SpanTermQuery( hun );
clauses[ 1 ] = (SpanTermQuery *) termQry40->clone();
SpanFirstQuery * include = _CLNEW SpanFirstQuery( termQry40, n, true );
SpanNearQuery * near = _CLNEW SpanNearQuery( clauses, clauses+2, n-1, true, true );
SpanFirstQuery * exclude = _CLNEW SpanFirstQuery( near, n-1, true );
SpanNotQuery * q = _CLNEW SpanNotQuery( include, exclude, true );
_CLLDECDELETE( hun );
_CLLDECDELETE( term40 );
checkHits( q, expectedDocs, sizeof( expectedDocs ) / sizeof( expectedDocs[ 0 ] ));
_CLLDELETE( q );
}
FastCharStream::~FastCharStream()
{
if (_ownsReader ){
_CLLDELETE(input);
}
_CLDELETE_LCARRAY(buffer);
}
void TestBasics::testSpanNearOr()
{
int32_t expectedDocs[] =
{
606, 607, 626, 627, 636, 637, 646, 647,
656, 657, 666, 667, 676, 677, 686, 687, 696, 697,
706, 707, 726, 727, 736, 737, 746, 747,
756, 757, 766, 767, 776, 777, 786, 787, 796, 797
};
SpanQuery * clauses[ 2 ];
Term * term1 = _CLNEW Term( _T( "field" ), _T( "six" ));
Term * term2 = _CLNEW Term( _T( "field" ), _T( "seven" ));
clauses[ 0 ] = _CLNEW SpanTermQuery( term1 );
clauses[ 1 ] = _CLNEW SpanTermQuery( term2 );
SpanOrQuery * to1 = _CLNEW SpanOrQuery( clauses, clauses+2, true );
clauses[ 0 ] = _CLNEW SpanTermQuery( term2 );
clauses[ 1 ] = _CLNEW SpanTermQuery( term1 );
SpanOrQuery * to2 = _CLNEW SpanOrQuery( clauses, clauses+2, true );
clauses[ 0 ] = to1;
clauses[ 1 ] = to2;
SpanNearQuery * query = _CLNEW SpanNearQuery( clauses, clauses+2, 10, true, true );
_CLLDECDELETE( term1 );
_CLLDECDELETE( term2 );
checkHits( query, expectedDocs, sizeof( expectedDocs ) / sizeof( expectedDocs[ 0 ] ));
_CLLDELETE( query );
}
void TestBasics::testSpanFirst()
{
int32_t expectedDocs[] =
{
5, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513,
514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527,
528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541,
542, 543, 544, 545, 546, 547, 548, 549, 550, 551, 552, 553, 554, 555,
556, 557, 558, 559, 560, 561, 562, 563, 564, 565, 566, 567, 568, 569,
570, 571, 572, 573, 574, 575, 576, 577, 578, 579, 580, 581, 582, 583,
584, 585, 586, 587, 588, 589, 590, 591, 592, 593, 594, 595, 596, 597,
598, 599
};
Term * term1 = _CLNEW Term( _T( "field" ), _T( "five" ));
SpanFirstQuery * query = _CLNEW SpanFirstQuery( _CLNEW SpanTermQuery( term1 ), 1, true );
_CLLDECDELETE( term1 );
checkHits( query, expectedDocs, sizeof( expectedDocs ) / sizeof( expectedDocs[ 0 ] ));
Explanation explanation1;
searcher->explain( query, 5, &explanation1 );
assertTrue( explanation1.getDetail( 0 )->getValue() > 0.0f ); // ToDo: Fix IndexSearcher::explain() method
Explanation explanation2;
searcher->explain( query, 599, &explanation2 );
assertTrue( explanation2.getDetail( 0 )->getValue() > 0.0f ); // ToDo: Fix IndexSearcher::explain() method
_CLLDELETE( query );
}
void TestBasics::testSpanExactNested()
{
int32_t expectedDocs[] = {333};
SpanQuery * clauses[ 2 ];
Term * term1 = _CLNEW Term( _T( "field" ), _T( "three" ));
Term * term2 = _CLNEW Term( _T( "field" ), _T( "hundred" ));
Term * term3 = _CLNEW Term( _T( "field" ), _T( "thirty" ));
clauses[ 0 ] = _CLNEW SpanTermQuery( term1 );
clauses[ 1 ] = _CLNEW SpanTermQuery( term2 );
SpanNearQuery * near1 = _CLNEW SpanNearQuery( clauses, clauses+2, 0, true, true );
clauses[ 0 ] = _CLNEW SpanTermQuery( term3 );
clauses[ 1 ] = _CLNEW SpanTermQuery( term1 );
SpanNearQuery * near2 = _CLNEW SpanNearQuery( clauses, clauses+2, 0, true, true );
clauses[ 0 ] = near1;
clauses[ 1 ] = near2;
SpanNearQuery * query = _CLNEW SpanNearQuery( clauses, clauses+2, 0, true, true );
_CLLDECDELETE( term1 );
_CLLDECDELETE( term2 );
_CLLDECDELETE( term3 );
checkHits( query, expectedDocs, sizeof( expectedDocs ) / sizeof( expectedDocs[ 0 ] ));
Explanation explanation1;
searcher->explain( query, 333, &explanation1 );
assertTrue( explanation1.getDetail( 0 )->getValue() > 0.0f ); // ToDo: Fix IndexSearcher::explain() method
_CLLDELETE( query );
}
IndexReader::~IndexReader(){
//Func - Destructor
// Destroys the instance and releases the writeLock if needed
//Pre - true
//Post - The instance has been destroyed if pre(writeLock) exists is has been released
_CLLDELETE(_internal);
}
void TestBasics::testSpanWithMultipleNotSingle()
{
int32_t expectedDocs[] = {801, 821, 831, 851, 861, 871, 881, 891};
SpanQuery * clauses[ 2 ];
Term * term1 = _CLNEW Term( _T( "field" ), _T( "eight" ));
Term * term2 = _CLNEW Term( _T( "field" ), _T( "one" ));
Term * term3 = _CLNEW Term( _T( "field" ), _T( "forty" ));
clauses[ 0 ] = _CLNEW SpanTermQuery( term1 );
clauses[ 1 ] = _CLNEW SpanTermQuery( term2 );
SpanNearQuery * near = _CLNEW SpanNearQuery( clauses, clauses+2, 4, true, true );
clauses[ 0 ] = _CLNEW SpanTermQuery( term3 );
SpanOrQuery * orQuery = _CLNEW SpanOrQuery( clauses, clauses+1, true );
SpanNotQuery * query = _CLNEW SpanNotQuery( near, orQuery, true );
_CLLDECDELETE( term1 );
_CLLDECDELETE( term2 );
_CLLDECDELETE( term3 );
checkHits( query, expectedDocs, sizeof( expectedDocs ) / sizeof( expectedDocs[ 0 ] ));
Explanation explanation1;
searcher->explain( query, 801, &explanation1 );
assertTrue( explanation1.getDetail( 0 )->getValue() > 0.0f ); // ToDo: Fix IndexSearcher::explain() method
Explanation explanation2;
searcher->explain( query, 891, &explanation2 );
assertTrue( explanation2.getDetail( 0 )->getValue() > 0.0f ); // ToDo: Fix IndexSearcher::explain() method
_CLLDELETE( query );
}
void TestBasics::testSpanNearExact()
{
int32_t expectedDocs[] = {77, 177, 277, 377, 477, 577, 677, 777, 877, 977};
SpanQuery * clauses[ 2 ];
Term * term1 = _CLNEW Term( _T( "field" ), _T( "seventy" ));
Term * term2 = _CLNEW Term( _T( "field" ), _T( "seven" ));
clauses[ 0 ] = _CLNEW SpanTermQuery( term1 );
clauses[ 1 ] = _CLNEW SpanTermQuery( term2 );
SpanNearQuery * query = _CLNEW SpanNearQuery( clauses, clauses+2, 0, true, true );
checkHits( query, expectedDocs, sizeof( expectedDocs ) / sizeof( expectedDocs[ 0 ] ));
Explanation explanation1;
searcher->explain( query, 77, &explanation1 );
assertTrue( explanation1.getDetail( 0 )->getValue() > 0.0f ); // ToDo: Fix IndexSearcher::explain() method
Explanation explanation2;
searcher->explain( query, 977, &explanation2 );
assertTrue( explanation2.getDetail( 0 )->getValue() > 0.0f ); // ToDo: Fix IndexSearcher::explain() method
QueryUtils::check( tc, clauses[ 0 ] );
QueryUtils::check( tc, clauses[ 1 ] );
QueryUtils::checkUnequal( tc, clauses[ 0 ], clauses[ 1 ] );
_CLLDECDELETE( term1 );
_CLLDECDELETE( term2 );
_CLLDELETE( query );
}
static void verifyNumDocs(CuTest *tc, Directory * dir, int numDocs) {
IndexReader * reader = IndexReader::open(dir);
assertEquals(numDocs, reader->maxDoc());
assertEquals(numDocs, reader->numDocs());
reader->close();
_CLLDELETE(reader);
}
void TestBasics::testTerm2()
{
Term * term = _CLNEW Term( _T( "field" ), _T( "seventish" ));
Query * query = new TermQuery( term );
_CLLDECDELETE( term );
checkHits( query, NULL, 0 );
_CLLDELETE( query );
}
_LUCENE_THREAD_FUNC(searchDocs, _searcher) {
WhitespaceAnalyzer an;
IndexSearcher * searcher = (IndexSearcher *)_searcher;
Query * query = QueryParser::parse(_T("one"), _T("content"), &an);
Hits * hits = searcher->search(query);
// _LUCENE_SLEEP(9999); //make sure that searchMutex is being waited on...
CONDITION_NOTIFYALL(searchCondition);
SCOPED_LOCK_MUTEX(deleteMutex);
_CLLDELETE(hits);
_CLLDELETE(query);
CONDITION_WAIT(deleteMutex, deleteCondition);
// _LUCENE_THREAD_FUNC_RETURN(0);
}
void testRAMDirectoryString (CuTest *tc) {
MockRAMDirectory * ramDir = _CLNEW MockRAMDirectory(indexDir);
checkDir(tc, ramDir);
ramDir->close();
_CLLDELETE(ramDir);
}
void TestSpansAdvanced::doTestBooleanQueryWithSpanQueries( const float_t expectedScore )
{
Term * t1 = _CLNEW Term( field_text, _T( "work" ));
Query * spanQuery = _CLNEW SpanTermQuery( t1 );
BooleanQuery * query = _CLNEW BooleanQuery();
query->add( spanQuery, false, BooleanClause::MUST );
query->add( spanQuery, false, BooleanClause::MUST );
TCHAR * expectedIds[] = { _T( "1" ), _T( "2" ), _T( "3" ), _T( "4" ) };
float_t expectedScores[] = { expectedScore, expectedScore, expectedScore, expectedScore };
assertHits( query, _T( "two span queries" ), expectedIds, expectedScores, 4 );
_CLLDECDELETE( t1 );
_CLLDELETE( spanQuery );
_CLLDELETE( query );
}
/// TestBooleanScorer.java, ported 5/9/2009
void testBooleanScorer(CuTest *tc) {
const TCHAR* FIELD = _T("category");
RAMDirectory directory;
TCHAR* values[] = { _T("1"), _T("2"), _T("3"), _T("4"), NULL};
try {
WhitespaceAnalyzer a;
IndexWriter* writer = _CLNEW IndexWriter(&directory, &a, true);
for (size_t i = 0; values[i]!=NULL; i++) {
Document* doc = _CLNEW Document();
doc->add(*_CLNEW Field(FIELD, values[i], Field::STORE_YES | Field::INDEX_TOKENIZED));
writer->addDocument(doc);
_CLLDELETE(doc);
}
writer->close();
_CLLDELETE(writer);
BooleanQuery* booleanQuery1 = _CLNEW BooleanQuery();
Term *t = _CLNEW Term(FIELD, _T("1"));
booleanQuery1->add(_CLNEW TermQuery(t), true, BooleanClause::SHOULD);
_CLDECDELETE(t);
t = _CLNEW Term(FIELD, _T("2"));
booleanQuery1->add(_CLNEW TermQuery(t), true, BooleanClause::SHOULD);
_CLDECDELETE(t);
BooleanQuery* query = _CLNEW BooleanQuery();
query->add(booleanQuery1, true, BooleanClause::MUST);
t = _CLNEW Term(FIELD, _T("9"));
query->add(_CLNEW TermQuery(t), true, BooleanClause::MUST_NOT);
_CLDECDELETE(t);
IndexSearcher *indexSearcher = _CLNEW IndexSearcher(&directory);
Hits *hits = indexSearcher->search(query);
CLUCENE_ASSERT(2 == hits->length()); // Number of matched documents
_CLLDELETE(hits);
_CLLDELETE(indexSearcher);
_CLLDELETE(query);
}
catch (CLuceneError& e) {
CuFail(tc, e.twhat());
}
}
/**
* Tests a single span query that matches multiple documents.
*/
void TestSpansAdvanced2::testSingleSpanQuery()
{
Term * t1 = _CLNEW Term( field_text, _T( "should" ));
Query * spanQuery = _CLNEW SpanTermQuery( t1 );
TCHAR * expectedIds[] = { _T( "B" ), _T( "D" ), _T( "1" ), _T( "2" ), _T( "3" ), _T( "4" ), _T( "A" ) };
float_t expectedScores[] = { 0.625f, 0.45927936f, 0.35355338f, 0.35355338f, 0.35355338f, 0.35355338f, 0.26516503f, };
assertHits( spanQuery, _T( "single span query" ), expectedIds, expectedScores, 7 );
_CLLDELETE( spanQuery );
_CLLDECDELETE( t1 );
}
void testIncludeLowerTrue(CuTest* tc)
{
WhitespaceAnalyzer a;
RAMDirectory* index = _CLNEW RAMDirectory();
IndexWriter* writer = _CLNEW IndexWriter(index,
&a, true);
Document doc;
doc.add(*_CLNEW Field(_T("Category"), _T("a 1"), Field::STORE_YES | Field::INDEX_TOKENIZED));
writer->addDocument(&doc); doc.clear();
doc.add(*_CLNEW Field(_T("Category"), _T("a 2"), Field::STORE_YES | Field::INDEX_TOKENIZED));
writer->addDocument(&doc); doc.clear();
doc.add(*_CLNEW Field(_T("Category"), _T("a 3"), Field::STORE_YES | Field::INDEX_TOKENIZED));
writer->addDocument(&doc); doc.clear();
writer->close();
_CLLDELETE(writer);
IndexSearcher* s = _CLNEW IndexSearcher(index);
Filter* f = _CLNEW RangeFilter(_T("Category"), _T("3"), _T("3"), true, true);
Term* t = _CLNEW Term(_T("Category"), _T("a"));
Query* q1 = _CLNEW TermQuery(t);
_CLLDECDELETE(t);
t = _CLNEW Term(_T("Category"), _T("3"));
Query* q2 = _CLNEW TermQuery(t);
_CLLDECDELETE(t);
Hits* h = s->search(q1);
assertTrue(h->length() == 3);
_CLLDELETE(h);
h = s->search(q2);
assertTrue(h->length() == 1);
_CLLDELETE(h);
h = s->search(q1, f);
assertTrue(h->length() == 1);
_CLLDELETE(h);
s->close();
_CLLDELETE(s);
_CLLDELETE(q1);
_CLLDELETE(q2);
_CLLDELETE(f);
index->close();
_CLLDECDELETE(index);
}
TCHAR* ConstantScoreQuery::toString(const TCHAR* /*field*/) const
{
StringBuffer buf;
buf.append(_T("ConstantScore("));
TCHAR* tmp = filter->toString();
buf.append(tmp);
_CLLDELETE(tmp);
buf.appendBoost(getBoost());
buf.appendChar(_T(')'));
return buf.giveBuffer();
}
// static
Query* MultiFieldQueryParser::parse(const TCHAR* query, const TCHAR** _fields, const uint8_t* flags, Analyzer* analyzer) {
BooleanQuery* bQuery = _CLNEW BooleanQuery();
for (size_t i = 0; _fields[i]!=NULL; i++) {
//TODO: this is really confusing... why not refactor _fields and flags to use a array object.
//flags can be NULL since NULL == 0...
/*if (flags[i] == NULL) {
_CLLDELETE(bQuery);
_CLTHROWA(CL_ERR_IllegalArgument, "_fields.length != flags.length");
}*/
QueryParser* qp = _CLNEW QueryParser(_fields[i], analyzer);
Query* q = qp->parse(query);
if (q!=NULL && // q never null, just being defensive
(!(q->instanceOf(BooleanQuery::getClassName())) || ((BooleanQuery*)q)->getClauseCount()>0)) {
bQuery->add(q, true, (BooleanClause::Occur)flags[i]);
} else
_CLLDELETE(q);
_CLLDELETE(qp);
}
return bQuery;
}
Explanation* explain(IndexReader* reader, int32_t doc) {
ConstantScorer* cs = (ConstantScorer*)scorer(reader);
bool exists = cs->bits->get(doc);
_CLDELETE(cs);
ComplexExplanation* result = _CLNEW ComplexExplanation();
if (exists) {
StringBuffer buf(100);
buf.append(_T("ConstantScoreQuery("));
TCHAR* tmp = parentQuery->filter->toString();
buf.append(tmp);
_CLDELETE_LCARRAY(tmp);
buf.append(_T("), product of:"));
result->setDescription(buf.getBuffer());
result->setValue(queryWeight);
result->setMatch(true);
result->addDetail(_CLNEW Explanation(parentQuery->getBoost(), _T("boost")));
result->addDetail(_CLNEW Explanation(queryNorm, _T("queryNorm")));
} else {
StringBuffer buf(100);
buf.append(_T("ConstantScoreQuery("));
TCHAR* tmp = parentQuery->filter->toString();
buf.append(tmp);
_CLLDELETE(tmp);
buf.append(_T(") doesn't match id "));
buf.appendInt(doc);
result->setDescription(buf.getBuffer());
result->setValue(0);
result->setMatch(true);
}
_CLLDELETE(cs);
return result;
}
//static
Query* MultiFieldQueryParser::parse(const TCHAR** _queries, const TCHAR** _fields, Analyzer* analyzer)
{
BooleanQuery* bQuery = _CLNEW BooleanQuery();
for (size_t i = 0; _fields[i]!=NULL; i++)
{
if (_queries[i] == NULL) {
_CLLDELETE(bQuery);
_CLTHROWA(CL_ERR_IllegalArgument, "_queries.length != _fields.length");
}
// TODO: Reuse qp instead of creating it over and over again
QueryParser* qp = _CLNEW QueryParser(_fields[i], analyzer);
Query* q = qp->parse(_queries[i]);
if (q!=NULL && // q never null, just being defensive
(!(q->instanceOf(BooleanQuery::getClassName()) || ((BooleanQuery*)q)->getClauseCount() > 0))) {
bQuery->add(q, true, BooleanClause::SHOULD);
} else
_CLLDELETE(q);
_CLLDELETE(qp);
}
return bQuery;
}
void SegmentInfos::clearto(size_t _min)
{
// Make sure we actually need to remove
if (infos.size() > _min) {
segmentInfosType::iterator itr;
segmentInfosType::iterator eitr = infos.end();
segmentInfosType::iterator bitr = infos.begin() + _min;
for(itr = bitr; itr != eitr; ++itr)
_CLLDELETE((*itr));
infos.erase(bitr, eitr);
}
}
