void testBoost()
{
// NOTE: uses index build in *this* setUp
IndexReader * pReader = IndexReader::open( m_pSmall );
IndexSearcher * pSearch = _CLNEW IndexSearcher( pReader );
Hits * pResult;
// test for correct application of query normalization
// must use a non score normalizing method for this.
Query * q = csrq( _T( "data" ), _T( "1" ), _T( "6" ), true, true );
q->setBoost( 100 );
pResult = pSearch->search( q );
for( size_t i = 1; i < pResult->length(); i++ )
{
assertTrueMsg( _T( "score was not was not correct" ), 1.0f == pResult->score( i ));
}
_CLDELETE( pResult );
_CLDELETE( q );
//
// Ensure that boosting works to score one clause of a query higher
// than another.
//
Query * q1 = csrq( _T( "data" ), _T( "A" ), _T( "A" ), true, true ); // matches document #0
q1->setBoost( .1f );
Query * q2 = csrq( _T( "data" ), _T( "Z" ), _T( "Z" ), true, true ); // matches document #1
BooleanQuery * bq = _CLNEW BooleanQuery( true );
bq->add( q1, true, BooleanClause::SHOULD );
bq->add( q2, true, BooleanClause::SHOULD );
pResult = pSearch->search( bq );
assertEquals( 1, pResult->id( 0 ));
assertEquals( 0, pResult->id( 1 ));
assertTrue( pResult->score( 0 ) > pResult->score( 1 ));
_CLDELETE( pResult );
_CLDELETE( bq );
q1 = csrq( _T( "data" ), _T( "A" ), _T( "A" ), true, true ); // matches document #0
q1->setBoost( 10.0f );
q2 = csrq( _T( "data" ), _T( "Z" ), _T( "Z" ), true, true ); // matches document #1
bq = _CLNEW BooleanQuery( true );
bq->add( q1, true, BooleanClause::SHOULD );
bq->add( q2, true, BooleanClause::SHOULD );
pResult = pSearch->search( bq );
assertEquals( 0, pResult->id( 0 ));
assertEquals( 1, pResult->id( 1 ));
assertTrue( pResult->score( 0 ) > pResult->score( 1 ));
_CLDELETE( pResult );
_CLDELETE( bq );
pSearch->close();
_CLDELETE( pSearch );
pReader->close();
_CLDELETE( pReader );
}
//static
Query* MultiFieldQueryParser::parse(const TCHAR* query, const TCHAR** fields, const uint8_t* flags, Analyzer* analyzer)
{
BooleanQuery* bQuery = _CLNEW BooleanQuery();
int32_t i = 0;
while ( fields[i] != NULL )
{
Query* q = QueryParser::parse(query, fields[i], analyzer);
uint8_t flag = flags[i];
switch (flag)
{
case MultiFieldQueryParser::REQUIRED_FIELD:
bQuery->add(q, true, true, false);
break;
case MultiFieldQueryParser::PROHIBITED_FIELD:
bQuery->add(q, true, false, true);
break;
default:
bQuery->add(q, true, false, false);
break;
}
i++;
}
return bQuery;
}
//static
Query* Query::mergeBooleanQueries(Query** queries) {
CL_NS(util)::CLVector<BooleanClause*> allClauses;
int32_t i = 0;
while ( queries[i] != NULL ){
BooleanQuery* bq = (BooleanQuery*)queries[i];
int32_t size = bq->getClauseCount();
BooleanClause** clauses = _CL_NEWARRAY(BooleanClause*, size);
bq->getClauses(clauses);
for (int32_t j = 0;j<size;++j ){
allClauses.push_back(clauses[j]);
j++;
}
_CLDELETE_ARRAY(clauses);
i++;
}
BooleanQuery* result = _CLNEW BooleanQuery();
CL_NS(util)::CLVector<BooleanClause*>::iterator itr = allClauses.begin();
while (itr != allClauses.end() ) {
result->add(*itr);
}
return result;
}
void testSrchWildcard(CuTest *tc ){
#ifdef NO_WILDCARD_QUERY
CuNotImpl(tc,_T("Wildcard"));
#else
CuAssert(tc,_T("Searcher was not open"),s!=NULL);
//testWildcard
_TestSearchesRun(tc, &a,s, _T("term*") );
_TestSearchesRun(tc, &a,s, _T("term*^2") );
_TestSearchesRun(tc, &a,s, _T("term~") );
_TestSearchesRun(tc, &a,s, _T("term^2~") );
_TestSearchesRun(tc, &a,s, _T("term~^2") );
_TestSearchesRun(tc, &a,s, _T("term*germ") );
_TestSearchesRun(tc, &a,s, _T("term*germ^3") );
//test problem reported by Gary Mangum
BooleanQuery* bq = _CLNEW BooleanQuery();
Term* upper = _CLNEW Term(_T("contents"),_T("0105"));
Term* lower = _CLNEW Term(_T("contents"),_T("0105"));
RangeQuery* rq=_CLNEW RangeQuery(lower,upper,true);
bq->add(rq,true,true,false);
_CLDECDELETE(upper);
_CLDECDELETE(lower);
Term* prefix = _CLNEW Term(_T("contents"),_T("reuters21578"));
PrefixQuery* pq = _CLNEW PrefixQuery(prefix);
_CLDECDELETE(prefix);
bq->add(pq,true,true,false);
Hits* h = NULL;
try{
h = s->search( bq );
}_CLFINALLY(
_CLDELETE(h);
_CLDELETE(bq);
);
/// 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());
}
}
//static
Query* MultiFieldQueryParser::parse(const TCHAR* query, const TCHAR** fields, Analyzer* analyzer)
{
BooleanQuery* bQuery = _CLNEW BooleanQuery();
int32_t i = 0;
while ( fields[i] != NULL ){
Query* q = QueryParser::parse(query, fields[i], analyzer);
bQuery->add(q, true, false, false);
i++;
}
return bQuery;
}
/// TestBooleanQuery.java, ported 5/9/2009
void testEquality(CuTest *tc) {
BooleanQuery* bq1 = _CLNEW BooleanQuery();
Term* t = _CLNEW Term(_T("field"), _T("value1"));
bq1->add(_CLNEW TermQuery(t), true, BooleanClause::SHOULD);
_CLDECDELETE(t);
t = _CLNEW Term(_T("field"), _T("value2"));
bq1->add(_CLNEW TermQuery(t), true, BooleanClause::SHOULD);
_CLDECDELETE(t);
BooleanQuery* nested1 = _CLNEW BooleanQuery();
t = _CLNEW Term(_T("field"), _T("nestedvalue1"));
nested1->add(_CLNEW TermQuery(t), true, BooleanClause::SHOULD);
_CLDECDELETE(t);
t = _CLNEW Term(_T("field"), _T("nestedvalue2"));
nested1->add(_CLNEW TermQuery(t), true, BooleanClause::SHOULD);
_CLDECDELETE(t);
bq1->add(nested1, true, BooleanClause::SHOULD);
BooleanQuery* bq2 = _CLNEW BooleanQuery();
t = _CLNEW Term(_T("field"), _T("value1"));
bq2->add(_CLNEW TermQuery(t), true, BooleanClause::SHOULD);
_CLDECDELETE(t);
t = _CLNEW Term(_T("field"), _T("value2"));
bq2->add(_CLNEW TermQuery(t), true, BooleanClause::SHOULD);
_CLDECDELETE(t);
BooleanQuery* nested2 = _CLNEW BooleanQuery();
t = _CLNEW Term(_T("field"), _T("nestedvalue1"));
nested2->add(_CLNEW TermQuery(t), true, BooleanClause::SHOULD);
_CLDECDELETE(t);
t = _CLNEW Term(_T("field"), _T("nestedvalue2"));
nested2->add(_CLNEW TermQuery(t), true, BooleanClause::SHOULD);
_CLDECDELETE(t);
bq2->add(nested2, true, BooleanClause::SHOULD);
CLUCENE_ASSERT(bq1->equals(bq2));
_CLLDELETE(bq1);
_CLLDELETE(bq2);
}
void TestBasics::testBoolean2()
{
Term * term1 = _CLNEW Term( _T( "field" ), _T( "sevento" ));
Term * term2 = _CLNEW Term( _T( "field" ), _T( "sevenly" ));
BooleanQuery * query = _CLNEW BooleanQuery();
query->add( _CLNEW TermQuery( term1 ), true, BooleanClause::MUST );
query->add( _CLNEW TermQuery( term2 ), true, BooleanClause::MUST );
_CLLDECDELETE( term1 );
_CLLDECDELETE( term2 );
checkHits( query, NULL, 0 );
_CLLDELETE( query );
}
void TestBasics::testBoolean()
{
int32_t expectedDocs[] = {77, 777, 177, 277, 377, 477, 577, 677, 770, 771, 772, 773, 774, 775, 776, 778, 779, 877, 977};
Term * term1 = _CLNEW Term( _T( "field" ), _T( "seventy" ));
Term * term2 = _CLNEW Term( _T( "field" ), _T( "seven" ));
BooleanQuery * query = _CLNEW BooleanQuery();
query->add( _CLNEW TermQuery( term1 ), true, BooleanClause::MUST );
query->add( _CLNEW TermQuery( term2 ), true, BooleanClause::MUST );
_CLLDECDELETE( term1 );
_CLLDECDELETE( term2 );
checkHits( query, expectedDocs, sizeof( expectedDocs ) / sizeof( expectedDocs[ 0 ] ));
_CLLDELETE( query );
}
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 );
}
Query* PrefixQuery::rewrite(IndexReader* reader){
BooleanQuery* query = _CLNEW BooleanQuery();
TermEnum* enumerator = reader->terms(prefix);
Term* lastTerm = NULL;
try {
const TCHAR* prefixText = prefix->text();
const TCHAR* prefixField = prefix->field();
const TCHAR* tmp;
size_t i;
int32_t prefixLen = prefix->textLength();
do {
lastTerm = enumerator->term();
if (lastTerm != NULL && lastTerm->field() == prefixField ){
//now see if term->text() starts with prefixText
int32_t termLen = lastTerm->textLength();
if ( prefixLen>termLen )
break; //the prefix is longer than the term, can't be matched
tmp = lastTerm->text();
//check for prefix match in reverse, since most change will be at the end
for ( i=prefixLen-1;i!=-1;--i ){
if ( tmp[i] != prefixText[i] ){
tmp=NULL;//signals inequality
break;
}
}
if ( tmp == NULL )
break;
TermQuery* tq = _CLNEW TermQuery(lastTerm); // found a match
tq->setBoost(getBoost()); // set the boost
query->add(tq,true,false, false); // add to query
} else
break;
_CLDECDELETE(lastTerm);
} while (enumerator->next());
}_CLFINALLY(
enumerator->close();
_CLDELETE(enumerator);
_CLDECDELETE(lastTerm);
);
/**
* Tests a single span query that matches multiple documents.
*/
void TestSpansAdvanced2::testMultipleDifferentSpanQueries()
{
Term * t1 = _CLNEW Term( field_text, _T( "should" ));
Term * t2 = _CLNEW Term( field_text, _T( "we" ));
Query * spanQuery1 = _CLNEW SpanTermQuery( t1 );
Query * spanQuery2 = _CLNEW SpanTermQuery( t2 );
BooleanQuery * query = _CLNEW BooleanQuery();
query->add( spanQuery1, true, BooleanClause::MUST );
query->add( spanQuery2, true, BooleanClause::MUST );
TCHAR * expectedIds[] = { _T( "D" ), _T( "A" ) };
// these values were pre LUCENE-413
// final float[] expectedScores = new float[] { 0.93163157f, 0.20698164f };
float_t expectedScores[] = { 1.0191123f, 0.93163157f };
assertHits( query, _T( "multiple different span queries" ), expectedIds, expectedScores, 2 );
_CLDELETE( query );
_CLLDECDELETE( t1 );
_CLLDECDELETE( t2 );
}
// 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;
}
void testBooleanOrderUnAffected()
{
// NOTE: uses index build in *this* setUp
IndexReader * pReader = IndexReader::open( m_pSmall );
IndexSearcher * pSearch = _CLNEW IndexSearcher( pReader );
// first do a regular RangeQuery which uses term expansion so
// docs with more terms in range get higher scores
Term * pLower = _CLNEW Term( _T( "data" ), _T( "1" ));
Term * pUpper = _CLNEW Term( _T( "data" ), _T( "4" ));
Query * rq = _CLNEW RangeQuery( pLower, pUpper, true );
_CLLDECDELETE( pUpper );
_CLLDECDELETE( pLower );
Hits * pExpected = pSearch->search( rq );
size_t numHits = pExpected->length();
// now do a boolean where which also contains a
// ConstantScoreRangeQuery and make sure the order is the same
BooleanQuery * q = _CLNEW BooleanQuery();
q->add( rq, true, BooleanClause::MUST );
q->add( csrq( _T( "data" ), _T( "1" ), _T( "6" ), true, true ), true, BooleanClause::MUST );
Hits * pActual = pSearch->search( q );
assertEqualsMsg( _T( "wrong number of hits" ), numHits, pActual->length() );
for( size_t i = 0; i < numHits; i++ )
{
assertEqualsMsg( _T( "mismatch in docid for a hit" ), pExpected->id( i ), pActual->id( i ));
}
_CLDELETE( pActual );
_CLDELETE( pExpected );
_CLDELETE( q );
pSearch->close();
_CLDELETE( pSearch );
pReader->close();
_CLDELETE( pReader );
}
//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;
}
/////////////////////////////////////////////////////////////////////////////
// CLucene specific
// Visual Studio 2005 shows memory leaks for this test, but some other
// tools do not detect any memory leaks. So what is right?
// IN VC80 shows memory leaks ONLY if both sub-queries are added as
// MUST BooleanClauses.
void testBooleanMemLeaks()
{
IndexReader * pReader = IndexReader::open( m_pSmall );
IndexSearcher * pSearch = _CLNEW IndexSearcher( pReader );
Query * q1 = csrq( _T( "data" ), _T( "A" ), _T( "A" ), true, true ); // matches document #0
Query * q2 = csrq( _T( "data" ), _T( "Z" ), _T( "Z" ), true, true ); // matches document #1
BooleanQuery * bq = _CLNEW BooleanQuery( true );
bq->add( q1, true, BooleanClause::MUST );
bq->add( q2, true, BooleanClause::MUST );
Hits * pResult = pSearch->search( bq );
_CLDELETE( pResult );
_CLDELETE( bq );
pSearch->close();
_CLDELETE( pSearch );
pReader->close();
_CLDELETE( pReader );
}
void testExtractFromBooleanQuery( CuTest * tc )
{
Directory * pIndex = setUpIndex();
IndexReader * pReader = IndexReader::open( pIndex );
TermSet termSet;
Term * t1 = _CLNEW Term( _T("data"), _T("aaaab") );
Term * t2 = _CLNEW Term( _T("data"), _T("aaabb") );
Term * t3 = _CLNEW Term( _T("data"), _T("aaabb") );
BooleanQuery * bq = _CLNEW BooleanQuery();
bq->add( _CLNEW TermQuery( t1 ), true, BooleanClause::SHOULD );
bq->add( _CLNEW TermQuery( t2 ), true, BooleanClause::SHOULD );
bq->add( _CLNEW TermQuery( t3 ), true, BooleanClause::SHOULD );
Query * rewrite = bq->rewrite( pReader );
rewrite->extractTerms( &termSet );
assertEqualsMsg( _T( "wrong number of terms" ), 2, termSet.size() );
for( TermSet::iterator itTerms = termSet.begin(); itTerms != termSet.end(); itTerms++ )
{
Term * pTerm = *itTerms;
assertTrueMsg( _T( "wrong term" ), ( 0 == t1->compareTo( pTerm ) || 0 == t2->compareTo( pTerm )));
}
clearTermSet( termSet );
_CLLDECDELETE( t1 );
_CLLDECDELETE( t2 );
_CLLDECDELETE( t3 );
if( rewrite != bq )
_CLDELETE( rewrite );
_CLDELETE( bq );
pReader->close();
_CLDELETE( pReader );
closeIndex( pIndex );
pIndex = NULL;
}
void
query (void)
{
ProgTime TotalStartTime, TotalInvfTime, TotalTextTime;
InitQueryTimes iqt;
query_data *qd;
TotalStartTime.RealTime = TotalStartTime.CPUTime = 0;
TotalInvfTime.RealTime = TotalInvfTime.CPUTime = 0;
TotalTextTime.RealTime = TotalTextTime.CPUTime = 0;
qd = InitQuerySystem (GetDefEnv ("mgdir", "./"),
GetDefEnv ("mgname", ""),
&iqt);
if (!qd)
FatalError (1, mg_errorstrs[mg_errno], mg_error_data);
start_up_stats (qd, iqt);
while (1)
{
ProgTime StartTime, InvfTime, TextTime;
char QueryType;
char OutputType;
char *line;
ResetFileStats (qd);
qd->max_mem_in_use = qd->mem_in_use = 0;
qd->tot_hops_taken += qd->hops_taken;
qd->tot_num_of_ptrs += qd->num_of_ptrs;
qd->tot_num_of_accum += qd->num_of_accum;
qd->tot_num_of_terms += qd->num_of_terms;
qd->tot_num_of_ans += qd->num_of_ans;
qd->tot_text_idx_lookups += qd->text_idx_lookups;
qd->hops_taken = qd->num_of_ptrs = 0;
qd->num_of_accum = qd->num_of_ans = qd->num_of_terms = 0;
qd->text_idx_lookups = 0;
Display_Stats (stderr);
Clear_Stats ();
line = get_query (qd);
if (!line || Quitting)
break;
GetPostProc (line);
GetTime (&StartTime);
FreeQueryDocs (qd);
QueryType = get_query_type ();
OutputType = get_output_type ();
/* No point in hiliting words on a docnum query */
if (OutputType == OUTPUT_HILITE && QueryType == QUERY_DOCNUMS)
OutputType = OUTPUT_TEXT;
switch (QueryType)
{
case QUERY_BOOLEAN:
{
char *maxdocs;
BooleanQueryInfo bqi;
maxdocs = GetDefEnv ("maxdocs", "all");
bqi.MaxDocsToRetrieve = strcmp (maxdocs, "all") ? atoi (maxdocs) : -1;
BooleanQuery (qd, line, &bqi);
break;
}
case QUERY_APPROX:
case QUERY_RANKED:
{
char *maxdocs;
char *maxterms;
char *maxaccum;
RankedQueryInfo rqi;
maxdocs = GetDefEnv ("maxdocs", "all");
maxterms = GetDefEnv ("max_terms", "all");
maxaccum = GetDefEnv ("max_accumulators", "all");
rqi.Sort = BooleanEnv (GetEnv ("sorted_terms"), 0);
rqi.QueryFreqs = BooleanEnv (GetEnv ("qfreq"), 1);
rqi.Exact = QueryType == QUERY_RANKED;
rqi.MaxDocsToRetrieve = strcmp (maxdocs, "all") ? atoi (maxdocs) : -1;
rqi.MaxTerms = strcmp (maxterms, "all") ? atoi (maxterms) : -1;
rqi.MaxParasToRetrieve = rqi.MaxDocsToRetrieve;
if (qd->id->ifh.InvfLevel == 3 && GetEnv ("maxparas"))
rqi.MaxParasToRetrieve = atoi (GetEnv ("maxparas"));
rqi.AccumMethod = toupper (*GetDefEnv ("accumulator_method", "A"));
rqi.MaxAccums = strcmp (maxaccum, "all") ? atoi (maxaccum) : -1;
rqi.HashTblSize = IntEnv (GetEnv ("hash_tbl_size"), 1000);
rqi.StopAtMaxAccum = BooleanEnv (GetEnv ("stop_at_max_accum"), 0);
rqi.skip_dump = GetEnv ("skip_dump");
RankedQuery (qd, line, &rqi);
break;
}
case QUERY_DOCNUMS:
{
DocnumsQuery (qd, line);
break;
}
}
GetTime (&InvfTime);
if (qd->DL)
MoreDocs (qd, line, OutputType);
GetTime (&TextTime);
if (BooleanEnv (GetEnv ("timestats"), 0) ||
BooleanEnv (GetEnv ("briefstats"), 0))
QueryTimeStats (&StartTime, &InvfTime, &TextTime);
if (BooleanEnv (GetEnv ("diskstats"), 0) ||
BooleanEnv (GetEnv ("briefstats"), 0))
File_Stats (qd);
if (BooleanEnv (GetEnv ("memstats"), 0) ||
BooleanEnv (GetEnv ("briefstats"), 0))
MemStats (qd);
if (BooleanEnv (GetEnv ("sizestats"), 0))
SizeStats (qd);
TotalInvfTime.RealTime += InvfTime.RealTime - StartTime.RealTime;
TotalInvfTime.CPUTime += InvfTime.CPUTime - StartTime.CPUTime;
TotalTextTime.RealTime += TextTime.RealTime - StartTime.RealTime;
TotalTextTime.CPUTime += TextTime.CPUTime - StartTime.CPUTime;
}
if (isatty (fileno (InFile)) && !Quitting)
fprintf (stderr, "\n");
shut_down_stats (qd, &TotalStartTime, &TotalInvfTime, &TotalTextTime);
Display_Stats (stderr);
}
reusableST->score = score;
reusableST->term = t;
} else {
continue;
}
reusableST = stQueue->insertWithOverflow(reusableST);
}
} while (enumerator->next());
} _CLFINALLY({
enumerator->close();
_CLLDELETE(enumerator);
//_CLLDELETE(reusableST);
});
BooleanQuery* query = _CLNEW BooleanQuery(true);
const size_t size = stQueue->size();
for(size_t i = 0; i < size; i++){
ScoreTerm* st = stQueue->pop();
TermQuery* tq = _CLNEW TermQuery(st->term); // found a match
tq->setBoost(getBoost() * st->score); // set the boost
query->add(tq, true, BooleanClause::SHOULD); // add to query
_CLLDELETE(st);
}
_CLLDELETE(stQueue);
return query;
}
CL_NS_END
/// TestBooleanPrefixQuery.java, ported 5/9/2009
void testBooleanPrefixQuery(CuTest* tc) {
RAMDirectory directory;
WhitespaceAnalyzer a;
TCHAR* categories[] = {_T("food"), _T("foodanddrink"),
_T("foodanddrinkandgoodtimes"), _T("food and drink"), NULL};
Query* rw1 = NULL;
Query* rw2 = NULL;
try {
IndexWriter* writer = _CLNEW IndexWriter(&directory, &a, true);
for (size_t i = 0; categories[i]!=NULL; i++) {
Document* doc = new Document();
doc->add(*_CLNEW Field(_T("category"), categories[i], Field::STORE_YES | Field::INDEX_UNTOKENIZED));
writer->addDocument(doc);
_CLLDELETE(doc);
}
writer->close();
_CLLDELETE(writer);
IndexReader* reader = IndexReader::open(&directory);
Term* t = _CLNEW Term(_T("category"), _T("foo"));
PrefixQuery* query = _CLNEW PrefixQuery(t);
_CLDECDELETE(t);
rw1 = query->rewrite(reader);
BooleanQuery* bq = _CLNEW BooleanQuery();
bq->add(query, true, BooleanClause::MUST);
rw2 = bq->rewrite(reader);
reader->close(); // TODO: check necessity (_CLLDELETE(reader) alone will not do the same cleanup)
_CLLDELETE(reader);
_CLLDELETE(bq);
} catch (CLuceneError& e) {
CuFail(tc, e.twhat());
}
BooleanQuery* bq1 = NULL;
if (rw1->instanceOf(BooleanQuery::getClassName())) {
bq1 = (BooleanQuery*) rw1;
}
BooleanQuery* bq2 = NULL;
if (rw2->instanceOf(BooleanQuery::getClassName())) {
bq2 = (BooleanQuery*) rw2;
} else {
CuFail(tc, _T("Rewrite"));
}
bool bClausesMatch = bq1->getClauseCount() == bq2->getClauseCount();
_CLLDELETE(rw1);
_CLLDELETE(rw2);
if (!bClausesMatch) {
CuFail(tc, _T("Number of Clauses Mismatch"));
}
}
