public virtual void TestCJKPhrase()
{
// individual CJK chars as terms
SimpleCJKAnalyzer analyzer = new SimpleCJKAnalyzer(this);
PhraseQuery expected = new PhraseQuery();
expected.Add(new Term("field", "中"));
expected.Add(new Term("field", "国"));
QueryBuilder builder = new QueryBuilder(analyzer);
Assert.AreEqual(expected, builder.CreatePhraseQuery("field", "中国"));
}
public string Visit_WithValidTermPhraseQuery_ReturnsValidReponse()
{
var query = new Lucene.Net.Search.PhraseQuery();
query.Add(new Lucene.Net.Index.Term("City", "TelAviv"));
var phraseQuery = new LucenePhraseQuery
{
LuceneQuery = query,
};
var luceneVisitor = new LuceneVisitor();
phraseQuery.Accept(luceneVisitor);
var es = phraseQuery.ESQuery;
Assert.NotNull(es);
var visitor = VisitorTestsUtils.CreateAndVisitRootVisitor();
visitor.Visit((QueryStringClause)es);
return(((QueryStringClause)es).KustoQL);
}
public string Visit_WithValidTermPhraseQuery_ReturnsValidReponse()
{
var query = new Lucene.Net.Search.PhraseQuery();
query.Add(new Lucene.Net.Index.Term("City", "TelAviv"));
var phraseQuery = new LucenePhraseQuery
{
LuceneQuery = query,
};
var luceneVisitor = new LuceneVisitor();
phraseQuery.Accept(luceneVisitor);
var es = phraseQuery.ESQuery;
Assert.NotNull(es);
var visitor = new ElasticSearchDSLVisitor(SchemaRetrieverMock.CreateMockSchemaRetriever());
visitor.Visit((QueryStringClause)es);
return(((QueryStringClause)es).KustoQL);
}
public virtual void TestPhrase()
{
PhraseQuery query = new PhraseQuery();
query.Add(new Term("field", "seventy"));
query.Add(new Term("field", "seven"));
CheckHits(query, new int[] { 77, 177, 277, 377, 477, 577, 677, 777, 877, 977 });
}
public virtual void TestPhrase2()
{
PhraseQuery query = new PhraseQuery();
query.Add(new Term("field", "seventish"));
query.Add(new Term("field", "sevenon"));
CheckHits(query, new int[] {});
}
private ScoreDoc[] Search()
{
// create PhraseQuery "term1 term2" and search
PhraseQuery pq = new PhraseQuery();
pq.Add(new Term(this.field, this.term1));
pq.Add(new Term(this.field, this.term2));
return(this.searcher.Search(pq, null, 1000).ScoreDocs);
}
public virtual void TestWithPendingDeletes3()
{
// main directory
Directory dir = new RAMDirectory();
// auxiliary directory
Directory aux = new RAMDirectory();
SetUpDirs(dir, aux);
IndexWriter writer = NewWriter(dir, false);
// Adds 10 docs, then replaces them with another 10
// docs, so 10 pending deletes:
for (int i = 0; i < 20; i++)
{
Document doc = new Document();
doc.Add(new Field("id", "" + (i % 10), Field.Store.NO, Field.Index.NOT_ANALYZED));
doc.Add(new Field("content", "bbb " + i, Field.Store.NO, Field.Index.ANALYZED));
writer.UpdateDocument(new Term("id", "" + (i % 10)), doc);
}
// Deletes one of the 10 added docs, leaving 9:
PhraseQuery q = new PhraseQuery();
q.Add(new Term("content", "bbb"));
q.Add(new Term("content", "14"));
writer.DeleteDocuments(q);
writer.AddIndexesNoOptimize(new Directory[] { aux });
writer.Optimize();
writer.Commit();
VerifyNumDocs(dir, 1039);
VerifyTermDocs(dir, new Term("content", "aaa"), 1030);
VerifyTermDocs(dir, new Term("content", "bbb"), 9);
writer.Close();
dir.Close();
aux.Close();
}
protected internal virtual void SmokeTestSearcher(IndexSearcher s)
{
RunQuery(s, new TermQuery(new Term("body", "united")));
RunQuery(s, new TermQuery(new Term("titleTokenized", "states")));
PhraseQuery pq = new PhraseQuery();
pq.Add(new Term("body", "united"));
pq.Add(new Term("body", "states"));
RunQuery(s, pq);
}
public void TestNegativePositions()
{
SinkTokenizer tokens = new SinkTokenizer();
Token t = new Token();
t.SetTermText("a");
t.SetPositionIncrement(0);
tokens.Add(t);
t.SetTermText("b");
t.SetPositionIncrement(1);
tokens.Add(t);
t.SetTermText("c");
tokens.Add(t);
MockRAMDirectory dir = new MockRAMDirectory();
IndexWriter w = new IndexWriter(dir, false, new WhitespaceAnalyzer(), true);
Document doc = new Document();
doc.Add(new Field("field", tokens));
w.AddDocument(doc);
w.Close();
IndexSearcher s = new IndexSearcher(dir);
PhraseQuery pq = new PhraseQuery();
pq.Add(new Term("field", "a"));
pq.Add(new Term("field", "b"));
pq.Add(new Term("field", "c"));
Hits hits = s.Search(pq);
Assert.AreEqual(1, hits.Length());
Query q = new SpanTermQuery(new Term("field", "a"));
hits = s.Search(q);
Assert.AreEqual(1, hits.Length());
TermPositions tps = s.GetIndexReader().TermPositions(new Term("field", "a"));
Assert.IsTrue(tps.Next());
Assert.AreEqual(1, tps.Freq());
Assert.AreEqual(-1, tps.NextPosition());
Assert.IsTrue(_TestUtil.CheckIndex(dir));
s.Close();
dir.Close();
}
private static void GetTermsFromPhraseQuery(PhraseQuery query, HashSetSupport terms, string fieldName)
{
Term[] queryTerms = query.GetTerms();
int i;
for (i = 0; i < queryTerms.Length; i++)
{
if ((fieldName == null) || (queryTerms[i].Field() == (string)(object)fieldName))
{
terms.Add(new WeightedTerm(query.GetBoost(), queryTerms[i].Text()));
}
}
}
public virtual void TestWithPendingDeletes3()
{
// main directory
Directory dir = new RAMDirectory();
// auxiliary directory
Directory aux = new RAMDirectory();
SetUpDirs(dir, aux);
IndexWriter writer = NewWriter(dir, false);
// Adds 10 docs, then replaces them with another 10
// docs, so 10 pending deletes:
for (int i = 0; i < 20; i++)
{
Document doc = new Document();
doc.Add(new Field("id", "" + (i % 10), Field.Store.NO, Field.Index.NOT_ANALYZED));
doc.Add(new Field("content", "bbb " + i, Field.Store.NO, Field.Index.ANALYZED));
writer.UpdateDocument(new Term("id", "" + (i % 10)), doc);
}
// Deletes one of the 10 added docs, leaving 9:
PhraseQuery q = new PhraseQuery();
q.Add(new Term("content", "bbb"));
q.Add(new Term("content", "14"));
writer.DeleteDocuments(q);
writer.AddIndexesNoOptimize(new Directory[]{aux});
writer.Optimize();
writer.Commit();
VerifyNumDocs(dir, 1039);
VerifyTermDocs(dir, new Term("content", "aaa"), 1030);
VerifyTermDocs(dir, new Term("content", "bbb"), 9);
writer.Close();
dir.Close();
aux.Close();
}
public virtual void TestNegativePositions()
{
DirectoryInfo oldIndexDir = CreateTempDir("negatives");
TestUtil.Unzip(GetDataFile(Bogus24IndexName), oldIndexDir);
Directory dir = NewFSDirectory(oldIndexDir);
DirectoryReader ir = DirectoryReader.Open(dir);
IndexSearcher @is = new IndexSearcher(ir);
PhraseQuery pq = new PhraseQuery();
pq.Add(new Term("field3", "more"));
pq.Add(new Term("field3", "text"));
TopDocs td = @is.Search(pq, 10);
Assert.AreEqual(1, td.TotalHits);
AtomicReader wrapper = SlowCompositeReaderWrapper.Wrap(ir);
DocsAndPositionsEnum de = wrapper.TermPositionsEnum(new Term("field3", "broken"));
Debug.Assert(de != null);
Assert.AreEqual(0, de.NextDoc());
Assert.AreEqual(0, de.NextPosition());
ir.Dispose();
TestUtil.CheckIndex(dir);
dir.Dispose();
}
public virtual void TestNegativePositions()
{
TokenStream tokens = new AnonymousClassTokenStream(this);
MockRAMDirectory dir = new MockRAMDirectory();
IndexWriter w = new IndexWriter(dir, new WhitespaceAnalyzer(), true, IndexWriter.MaxFieldLength.UNLIMITED);
Document doc = new Document();
doc.Add(new Field("field", tokens));
w.AddDocument(doc);
w.Commit();
IndexSearcher s = new IndexSearcher(dir);
PhraseQuery pq = new PhraseQuery();
pq.Add(new Term("field", "a"));
pq.Add(new Term("field", "b"));
pq.Add(new Term("field", "c"));
ScoreDoc[] hits = s.Search(pq, null, 1000).scoreDocs;
Assert.AreEqual(1, hits.Length);
Query q = new SpanTermQuery(new Term("field", "a"));
hits = s.Search(q, null, 1000).scoreDocs;
Assert.AreEqual(1, hits.Length);
TermPositions tps = s.GetIndexReader().TermPositions(new Term("field", "a"));
Assert.IsTrue(tps.Next());
Assert.AreEqual(1, tps.Freq());
Assert.AreEqual(0, tps.NextPosition());
w.Close();
Assert.IsTrue(_TestUtil.CheckIndex(dir));
s.Close();
dir.Close();
}
public virtual void TestPhrase()
{
PhraseQuery query = new PhraseQuery();
query.Add(new Term("field", "seventy"));
query.Add(new Term("field", "seven"));
CheckHits(query, new int[]{77, 177, 277, 377, 477, 577, 677, 777, 877, 977});
}
public virtual void TestWithPendingDeletes3()
{
// main directory
Directory dir = NewDirectory();
// auxiliary directory
Directory aux = NewDirectory();
SetUpDirs(dir, aux);
IndexWriter writer = NewWriter(dir, NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random())).SetOpenMode(OpenMode_e.APPEND));
// Adds 10 docs, then replaces them with another 10
// docs, so 10 pending deletes:
for (int i = 0; i < 20; i++)
{
Document doc = new Document();
doc.Add(NewStringField("id", "" + (i % 10), Field.Store.NO));
doc.Add(NewTextField("content", "bbb " + i, Field.Store.NO));
writer.UpdateDocument(new Term("id", "" + (i % 10)), doc);
}
// Deletes one of the 10 added docs, leaving 9:
PhraseQuery q = new PhraseQuery();
q.Add(new Term("content", "bbb"));
q.Add(new Term("content", "14"));
writer.DeleteDocuments(q);
writer.AddIndexes(aux);
writer.ForceMerge(1);
writer.Commit();
VerifyNumDocs(dir, 1039);
VerifyTermDocs(dir, new Term("content", "aaa"), 1030);
VerifyTermDocs(dir, new Term("content", "bbb"), 9);
writer.Dispose();
dir.Dispose();
aux.Dispose();
}
public virtual void TestGetBestFragmentsFilteredPhraseQuery()
{
RangeFilter rf = new RangeFilter("contents", "john", "john", true, true);
PhraseQuery pq = new PhraseQuery();
pq.Add(new Term("contents", "john"));
pq.Add(new Term("contents", "kennedy"));
FilteredQuery fq = new FilteredQuery(pq, rf);
DoSearching(fq);
DoStandardHighlights();
//Currently highlights "John" and "Kennedy" separately
Assert.IsTrue(numHighlights == 2, "Failed to find correct number of highlights " + numHighlights + " found");
}
private Hits Search()
{
// create PhraseQuery "term1 term2" and search
PhraseQuery pq = new PhraseQuery();
pq.Add(new Term(this.field, this.term1));
pq.Add(new Term(this.field, this.term2));
return this.searcher.Search(pq);
}
public virtual void TestBasic()
{
Directory dir = NewDirectory();
Analyzer analyzer = new MockAnalyzer(Random());
IndexWriter writer = new IndexWriter(dir, NewIndexWriterConfig(TEST_VERSION_CURRENT, analyzer).SetMaxBufferedDocs(2).SetSimilarity(new SimpleSimilarity()).SetMergePolicy(NewLogMergePolicy(2)));
StringBuilder sb = new StringBuilder(265);
string term = "term";
for (int i = 0; i < 30; i++)
{
Document doc = new Document();
sb.Append(term).Append(" ");
string content = sb.ToString();
Field noTf = NewField("noTf", content + (i % 2 == 0 ? "" : " notf"), OmitType);
doc.Add(noTf);
Field tf = NewField("tf", content + (i % 2 == 0 ? " tf" : ""), NormalType);
doc.Add(tf);
writer.AddDocument(doc);
//System.out.println(d);
}
writer.ForceMerge(1);
// flush
writer.Dispose();
/*
* Verify the index
*/
IndexReader reader = DirectoryReader.Open(dir);
IndexSearcher searcher = NewSearcher(reader);
searcher.Similarity = new SimpleSimilarity();
Term a = new Term("noTf", term);
Term b = new Term("tf", term);
Term c = new Term("noTf", "notf");
Term d = new Term("tf", "tf");
TermQuery q1 = new TermQuery(a);
TermQuery q2 = new TermQuery(b);
TermQuery q3 = new TermQuery(c);
TermQuery q4 = new TermQuery(d);
PhraseQuery pq = new PhraseQuery();
pq.Add(a);
pq.Add(c);
try
{
searcher.Search(pq, 10);
Assert.Fail("did not hit expected exception");
}
catch (Exception e)
{
Exception cause = e;
// If the searcher uses an executor service, the IAE is wrapped into other exceptions
while (cause.InnerException != null)
{
cause = cause.InnerException;
}
if (!(cause is InvalidOperationException))
{
throw new InvalidOperationException("Expected an IAE", e);
} // else OK because positions are not indexed
}
searcher.Search(q1, new CountingHitCollectorAnonymousInnerClassHelper(this));
//System.out.println(CountingHitCollector.getCount());
searcher.Search(q2, new CountingHitCollectorAnonymousInnerClassHelper2(this));
//System.out.println(CountingHitCollector.getCount());
searcher.Search(q3, new CountingHitCollectorAnonymousInnerClassHelper3(this));
//System.out.println(CountingHitCollector.getCount());
searcher.Search(q4, new CountingHitCollectorAnonymousInnerClassHelper4(this));
//System.out.println(CountingHitCollector.getCount());
BooleanQuery bq = new BooleanQuery();
bq.Add(q1, Occur.MUST);
bq.Add(q4, Occur.MUST);
searcher.Search(bq, new CountingHitCollectorAnonymousInnerClassHelper5(this));
Assert.AreEqual(15, CountingHitCollector.Count);
reader.Dispose();
dir.Dispose();
}
public virtual void TestPhraseQueryPositionIncrements()
{
PhraseQuery expected = new PhraseQuery();
expected.Add(new Term("field", "1"));
expected.Add(new Term("field", "2"), 2);
CharacterRunAutomaton stopList = new CharacterRunAutomaton((new RegExp("[sS][tT][oO][pP]")).ToAutomaton());
Analyzer analyzer = new MockAnalyzer(Random(), MockTokenizer.WHITESPACE, false, stopList);
QueryBuilder builder = new QueryBuilder(analyzer);
Assert.AreEqual(expected, builder.CreatePhraseQuery("field", "1 stop 2"));
}
public static Lucene.Net.Search.Query ConvertQueryToLuceneQuery(Query query)
{
if (query == null)
{
throw new ArgumentNullException("query");
}
Lucene.Net.Search.Query lQuery;
if (query is MatchAllDocsQuery)
{
var lMatchAllDocsQuery = new Lucene.Net.Search.MatchAllDocsQuery();
lQuery = lMatchAllDocsQuery;
}
else if (query is TermQuery)
{
var termQuery = query as TermQuery;
var term = Term.ConvertToLuceneTerm(termQuery.Term);
lQuery = new Lucene.Net.Search.TermQuery(term);
}
else if (query is TermRangeQuery)
{
var termRangeQuery = query as TermRangeQuery;
var lTermRangeQuery = new Lucene.Net.Search.TermRangeQuery(termRangeQuery.FieldName,
termRangeQuery.LowerTerm,
termRangeQuery.UpperTerm,
termRangeQuery.LowerInclusive,
termRangeQuery.UpperInclusive);
lQuery = lTermRangeQuery;
}
else if (query is PhraseQuery)
{
var phraseQuery = query as PhraseQuery;
var lPhraseQuery = new Lucene.Net.Search.PhraseQuery();
foreach (var term in phraseQuery.Terms)
{
var lTerm = Term.ConvertToLuceneTerm(term);
lPhraseQuery.Add(lTerm);
}
if (phraseQuery.Slop.HasValue)
{
lPhraseQuery.Slop = phraseQuery.Slop.Value;
}
lQuery = lPhraseQuery;
}
else if (query is PrefixQuery)
{
var prefixQuery = query as PrefixQuery;
var term = Term.ConvertToLuceneTerm(prefixQuery.Term);
var lPrefixQuery = new Lucene.Net.Search.PrefixQuery(term);
lQuery = lPrefixQuery;
}
else if (query is RegexQuery)
{
var regexQuery = query as RegexQuery;
var term = Term.ConvertToLuceneTerm(regexQuery.Term);
var lRegexQuery = new Contrib.Regex.RegexQuery(term);
lQuery = lRegexQuery;
}
else if (query is FuzzyQuery)
{
var fuzzyQuery = query as FuzzyQuery;
var term = Term.ConvertToLuceneTerm(fuzzyQuery.Term);
var lFuzzyQuery = new Lucene.Net.Search.FuzzyQuery(term);
lQuery = lFuzzyQuery;
}
else if (query is BooleanQuery)
{
var booleanQuery = query as BooleanQuery;
var lBooleanQuery = new Lucene.Net.Search.BooleanQuery();
foreach (var clause in booleanQuery.Clauses)
{
var lNestedQuery = Query.ConvertQueryToLuceneQuery(clause.Query);
Lucene.Net.Search.Occur lOccur;
switch (clause.Occur)
{
case Occur.Must:
lOccur = Lucene.Net.Search.Occur.MUST;
break;
case Occur.MustNot:
lOccur = Lucene.Net.Search.Occur.MUST_NOT;
break;
case Occur.Should:
lOccur = Lucene.Net.Search.Occur.SHOULD;
break;
default:
throw new InvalidOperationException("Occur not implemented or defined.");
}
var lClause = new Lucene.Net.Search.BooleanClause(lNestedQuery, lOccur);
lBooleanQuery.Add(lClause);
}
if (booleanQuery.MinimumNumberShouldMatch.HasValue)
{
lBooleanQuery.MinimumNumberShouldMatch = booleanQuery.MinimumNumberShouldMatch.Value;
}
lQuery = lBooleanQuery;
}
else if (query is WildcardQuery)
{
var wildcardQuery = query as WildcardQuery;
var lTerm = Term.ConvertToLuceneTerm(wildcardQuery.Term);
var lWildcardQuery = new Lucene.Net.Search.WildcardQuery(lTerm);
lQuery = lWildcardQuery;
}
else if (query is DoubleNumericRangeQuery)
{
var doubleNumericRangeQuery = query as DoubleNumericRangeQuery;
var ldoubleNumericRangeQuery = Lucene.Net.Search.NumericRangeQuery.NewDoubleRange(
doubleNumericRangeQuery.FieldName,
doubleNumericRangeQuery.Min,
doubleNumericRangeQuery.Max,
doubleNumericRangeQuery.MinInclusive,
doubleNumericRangeQuery.MaxInclusive);
lQuery = ldoubleNumericRangeQuery;
}
else if (query is FloatNumericRangeQuery)
{
var floatNumericRangeQuery = query as FloatNumericRangeQuery;
var lfloatNumericRangeQuery = Lucene.Net.Search.NumericRangeQuery.NewFloatRange(
floatNumericRangeQuery.FieldName,
floatNumericRangeQuery.Min,
floatNumericRangeQuery.Max,
floatNumericRangeQuery.MinInclusive,
floatNumericRangeQuery.MaxInclusive);
lQuery = lfloatNumericRangeQuery;
}
else if (query is IntNumericRangeQuery)
{
var intNumericRangeQuery = query as IntNumericRangeQuery;
var lintNumericRangeQuery = Lucene.Net.Search.NumericRangeQuery.NewIntRange(
intNumericRangeQuery.FieldName,
intNumericRangeQuery.Min,
intNumericRangeQuery.Max,
intNumericRangeQuery.MinInclusive,
intNumericRangeQuery.MaxInclusive);
lQuery = lintNumericRangeQuery;
}
else if (query is LongNumericRangeQuery)
{
var longNumericRangeQuery = query as LongNumericRangeQuery;
var llongNumericRangeQuery = Lucene.Net.Search.NumericRangeQuery.NewLongRange(
longNumericRangeQuery.FieldName,
longNumericRangeQuery.Min,
longNumericRangeQuery.Max,
longNumericRangeQuery.MinInclusive,
longNumericRangeQuery.MaxInclusive);
lQuery = llongNumericRangeQuery;
}
else if (query is QueryParserQuery)
{
var queryParserQuery = query as QueryParserQuery;
var queryParser = new Lucene.Net.QueryParsers.QueryParser(Version.LUCENE_30,
queryParserQuery.DefaultField,
new StandardAnalyzer(Version.LUCENE_30))
{
AllowLeadingWildcard =
queryParserQuery.AllowLeadingWildcard
};
lQuery = queryParser.Parse(queryParserQuery.Query);
}
else if (query is MultiFieldQueryParserQuery)
{
var multiFieldQueryParserQuery = query as MultiFieldQueryParserQuery;
if (multiFieldQueryParserQuery.FieldNames == null)
{
multiFieldQueryParserQuery.FieldNames = new List <string>();
}
var queryParser = new Lucene.Net.QueryParsers.MultiFieldQueryParser(Lucene.Net.Util.Version.LUCENE_30, multiFieldQueryParserQuery.FieldNames.ToArray(), new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30));
lQuery = queryParser.Parse(multiFieldQueryParserQuery.Query);
}
else
{
throw new ArgumentException(@"Unknown or invalid query object", "query");
}
if (query.Boost.HasValue)
{
lQuery.Boost = query.Boost.Value;
}
return(lQuery);
}
public virtual void TestPhrase2()
{
PhraseQuery query = new PhraseQuery();
query.Add(new Term("field", "seventish"));
query.Add(new Term("field", "sevenon"));
CheckHits(query, new int[]{});
}
private ScoreDoc[] Search()
{
// create PhraseQuery "term1 term2" and search
PhraseQuery pq = new PhraseQuery();
pq.Add(new Term(this.field, this.term1));
pq.Add(new Term(this.field, this.term2));
return this.searcher.Search(pq, null, 1000).ScoreDocs;
}
public virtual void TestPositionIncrementMultiFields()
{
Directory dir = NewDirectory();
RandomIndexWriter writer = new RandomIndexWriter(Random(), dir);
writer.AddDocument(MakeDocumentWithFields());
IndexReader reader = writer.Reader;
IndexSearcher searcher = NewSearcher(reader);
PhraseQuery query = new PhraseQuery();
query.Add(new Term("indexed_not_tokenized", "test1"));
query.Add(new Term("indexed_not_tokenized", "test2"));
ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
Assert.AreEqual(1, hits.Length);
DoAssert(searcher.Doc(hits[0].Doc), true);
writer.Dispose();
reader.Dispose();
dir.Dispose();
}
