public void TestRollbackIntegrityWithBufferFlush()
{
Directory dir = new MockRAMDirectory();
IndexWriter w = new IndexWriter(dir, new WhitespaceAnalyzer(), IndexWriter.MaxFieldLength.UNLIMITED);
for (int i = 0; i < 5; i++)
{
Document doc = new Document();
doc.Add(new Field("pk", i.ToString(), Field.Store.YES, Field.Index.ANALYZED_NO_NORMS));
w.AddDocument(doc);
}
w.Close();
// If buffer size is small enough to cause a flush, errors ensue...
w = new IndexWriter(dir, new WhitespaceAnalyzer(), IndexWriter.MaxFieldLength.UNLIMITED);
w.SetMaxBufferedDocs(2);
Term pkTerm = new Term("pk", "");
for (int i = 0; i < 3; i++)
{
Document doc = new Document();
String value = i.ToString();
doc.Add(new Field("pk", value, Field.Store.YES, Field.Index.ANALYZED_NO_NORMS));
doc.Add(new Field("text", "foo", Field.Store.YES, Field.Index.ANALYZED_NO_NORMS));
w.UpdateDocument(pkTerm.CreateTerm(value), doc);
}
w.Rollback();
IndexReader r = IndexReader.Open(dir, true);
Assert.AreEqual(5, r.NumDocs(), "index should contain same number of docs post rollback");
r.Close();
dir.Close();
}
internal SegmentMergeInfo(int b, TermEnum te, IndexReader r)
{
base_Renamed = b;
reader = r;
termEnum = te;
term = te.Term;
}
public static BooleanQuery ParseRange(string fieldName, long lowerValue, long upperValue, bool inclusive)
{
if (lowerValue > upperValue)
{
return null;
}
//var rangeQuery = new BooleanQuery();
var dateQuery = new BooleanQuery();
BooleanQuery.SetMaxClauseCount(int.MaxValue);
for (long i = lowerValue; i < upperValue; i++)
{
var term = new Term(fieldName, i.ToString());
var q = new TermQuery(term);
dateQuery.Add(q, BooleanClause.Occur.SHOULD);
}
if (inclusive)
{
var term = new Term(fieldName, upperValue.ToString());
var q = new TermQuery(term);
dateQuery.Add(q, BooleanClause.Occur.SHOULD);
}
//if (dateQuery.GetClauses() != null || dateQuery.GetClauses().Length != 0)
//{
// rangeQuery.Add(dateQuery, BooleanClause.Occur.MUST);
//}
return dateQuery;
}
public virtual void TestAnyChanges()
{
DocumentsWriterDeleteQueue queue = new DocumentsWriterDeleteQueue();
int size = 200 + Random().Next(500) * RANDOM_MULTIPLIER;
int termsSinceFreeze = 0;
int queriesSinceFreeze = 0;
for (int i = 0; i < size; i++)
{
Term term = new Term("id", "" + i);
if (Random().Next(10) == 0)
{
queue.AddDelete(new TermQuery(term));
queriesSinceFreeze++;
}
else
{
queue.AddDelete(term);
termsSinceFreeze++;
}
Assert.IsTrue(queue.AnyChanges());
if (Random().Next(5) == 0)
{
FrozenBufferedUpdates freezeGlobalBuffer = queue.FreezeGlobalBuffer(null);
Assert.AreEqual(termsSinceFreeze, freezeGlobalBuffer.TermCount);
Assert.AreEqual(queriesSinceFreeze, ((Query[])freezeGlobalBuffer.Queries_Nunit()).Length);
queriesSinceFreeze = 0;
termsSinceFreeze = 0;
Assert.IsFalse(queue.AnyChanges());
}
}
}
internal int DocIDUpto = -1; // unassigned until applied, and confusing that it's here, when it's just used in BufferedDeletes...
/// <summary>
/// Constructor.
/// </summary>
/// <param name="term"> the <seealso cref="Term"/> which determines the documents that will be updated </param>
/// <param name="field"> the <seealso cref="NumericDocValuesField"/> to update </param>
/// <param name="value"> the updated value </param>
protected internal DocValuesUpdate(DocValuesFieldUpdates.Type_e type, Term term, string field, object value)
{
this.Type = type;
this.Term = term;
this.Field = field;
this.Value = value;
}
static void ProcessTermClause(BooleanQuery bq, TermClause term)
{
Term t = new Term(term.Field, term.Value.ToLower());
Lucene.Net.Search.Query q = null;
if (term.ValueType == TermClauseType.Wildcard && term.Value.IndexOf('*') == term.Value.Length - 1)
{
q = new PrefixQuery(new Term(term.Field, term.Value.Substring(0, term.Value.Length - 1)));
}
else if (term.ValueType == TermClauseType.Wildcard)
{
q = new WildcardQuery(t);
}
else if (term.ValueType == TermClauseType.Fuzzy)
{
q = new FuzzyQuery(t);
}
else
{
q = new TermQuery(t);
}
if (term.Boost > 0)
{
q.SetBoost(term.Boost);
}
bq.Add(
q,
Translate(term.Type)
);
}
public virtual void TestSimpleSkip()
{
RAMDirectory dir = new RAMDirectory();
IndexWriter writer = new IndexWriter(dir, new PayloadAnalyzer(), true, IndexWriter.MaxFieldLength.LIMITED);
Term term = new Term("test", "a");
for (int i = 0; i < 5000; i++)
{
Document d1 = new Document();
d1.Add(new Field(term.Field(), term.Text(), Field.Store.NO, Field.Index.ANALYZED));
writer.AddDocument(d1);
}
writer.Flush();
writer.Optimize();
writer.Close();
IndexReader reader = SegmentReader.GetOnlySegmentReader(dir);
SegmentTermPositions tp = (SegmentTermPositions) reader.TermPositions();
tp.freqStream_ForNUnit = new CountingStream(this, tp.freqStream_ForNUnit);
for (int i = 0; i < 2; i++)
{
counter = 0;
tp.Seek(term);
CheckSkipTo(tp, 14, 185); // no skips
CheckSkipTo(tp, 17, 190); // one skip on level 0
CheckSkipTo(tp, 287, 200); // one skip on level 1, two on level 0
// this test would fail if we had only one skip level,
// because than more bytes would be read from the freqStream
CheckSkipTo(tp, 4800, 250); // one skip on level 2
}
}
public void TestTermSearch()
{
using (var dir = FSDirectory.Open(TestEnvironment.TestIndexDirectory))
using (var indexSearcher = new IndexSearcher(dir))
{
var termSubjectAnt = new Term("subject", "ant");
var termQuerySubjectAnt = new TermQuery(termSubjectAnt);
var topDocsSubjectAnt = indexSearcher.Search(termQuerySubjectAnt, 10);
// title=Ant in Action
// subject=apache ant build tool junit java development
Assert.Equal(1, topDocsSubjectAnt.TotalHits);
var termSubjectJUnit = new Term("subject", "junit");
var termQuerySubjectJUnit = new TermQuery(termSubjectJUnit);
var topDocsSubjectJUnit = indexSearcher.Search(termQuerySubjectJUnit, 10);
// ExplainResults(indexSearcher, termQuerySubjectJUnit, topDocsSubjectJUnit);
// title=JUnit in Action, Second Edition
// subject=junit unit testing mock objects
// title=Ant in Action
// subject=apache ant build tool junit java development
Assert.Equal(2, topDocsSubjectJUnit.TotalHits); // Ants in Action, "JUnit in Action, Second Edition"
}
}
public override int DocFreq(Term t)
{
int total = 0; // sum freqs in segments
for (int i = 0; i < subReaders.Length; i++)
total += subReaders[i].DocFreq(t);
return total;
}
/// <summary>macro for readability </summary>
public static Query Cswcq(Term wild)
{
WildcardQuery query = new WildcardQuery(wild);
query.RewriteMethod = MultiTermQuery.CONSTANT_SCORE_FILTER_REWRITE;
return(query);
}
public override Query GetFieldQuery(string field, string queryText)
{
HashSet<string> set;
if(untokenized.TryGetValue(field, out set))
{
if (set.Contains(queryText))
return new TermQuery(new Term(field, queryText));
}
var fieldQuery = base.GetFieldQuery(field, queryText);
if (fieldQuery is TermQuery
&& queryText.EndsWith("*")
&& !queryText.EndsWith(@"\*")
&& queryText.Contains(" "))
{
var analyzer = GetAnalyzer();
var tokenStream = analyzer.ReusableTokenStream(field, new StringReader(queryText.Substring(0, queryText.Length-1)));
var sb = new StringBuilder();
while (tokenStream.IncrementToken())
{
var attribute = (TermAttribute)tokenStream.GetAttribute(typeof(TermAttribute));
if (sb.Length != 0)
sb.Append(' ');
sb.Append(attribute.Term());
}
var prefix = new Term(field, sb.ToString());
return new PrefixQuery(prefix);
}
return fieldQuery;
}
public virtual void TestHashCodeAndEquals()
{
MultiPhraseQuery query1 = new MultiPhraseQuery();
MultiPhraseQuery query2 = new MultiPhraseQuery();
Assert.AreEqual(query1.GetHashCode(), query2.GetHashCode());
Assert.True(query1.Equals(query2));
Term term1 = new Term("someField", "someText");
query1.Add(term1);
query2.Add(term1);
Assert.AreEqual(query1.GetHashCode(), query2.GetHashCode());
Assert.AreEqual(query1, query2);
Term term2 = new Term("someField", "someMoreText");
query1.Add(term2);
Assert.IsFalse(query1.GetHashCode() == query2.GetHashCode());
Assert.IsFalse(query1.Equals(query2));
query2.Add(term2);
Assert.AreEqual(query1.GetHashCode(), query2.GetHashCode());
Assert.AreEqual(query1, query2);
}
internal readonly Term[] Terms; // for repetitions initialization
internal PhrasePositions(DocsAndPositionsEnum postings, int o, int ord, Term[] terms)
{
this.Postings = postings;
Offset = o;
this.Ord = ord;
this.Terms = terms;
}
private void CheckSplitting(Directory dir, Term splitTerm, int leftCount, int rightCount)
{
using (Directory dir1 = NewDirectory())
{
using (Directory dir2 = NewDirectory())
{
PKIndexSplitter splitter = new PKIndexSplitter(dir, dir1, dir2, splitTerm,
NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random())),
NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random())));
splitter.Split();
using (IndexReader ir1 = DirectoryReader.Open(dir1))
{
using (IndexReader ir2 = DirectoryReader.Open(dir2))
{
assertEquals(leftCount, ir1.NumDocs);
assertEquals(rightCount, ir2.NumDocs);
CheckContents(ir1, "1");
CheckContents(ir2, "2");
}
}
}
}
}
public Result Search (string term, int count, int start) {
try {
term = term.ToLower ();
Term htTerm = new Term ("hottext", term);
Query qq1 = new FuzzyQuery (htTerm);
Query qq2 = new TermQuery (htTerm);
qq2.Boost = 10f;
Query qq3 = new PrefixQuery (htTerm);
qq3.Boost = 10f;
DisjunctionMaxQuery q1 = new DisjunctionMaxQuery (0f);
q1.Add (qq1);
q1.Add (qq2);
q1.Add (qq3);
Query q2 = new TermQuery (new Term ("text", term));
q2.Boost = 3f;
Query q3 = new TermQuery (new Term ("examples", term));
q3.Boost = 3f;
DisjunctionMaxQuery q = new DisjunctionMaxQuery (0f);
q.Add (q1);
q.Add (q2);
q.Add (q3);
TopDocs top = SearchInternal (q, count, start);
Result r = new Result (term, searcher, top.ScoreDocs);
Results.Add (r);
return r;
} catch (IOException) {
Console.WriteLine ("No index in {0}", dir);
return null;
}
}
public virtual Query GetQuery(XmlElement e)
{
string fieldName = DOMUtils.GetAttributeWithInheritanceOrFail(e, "fieldName");
string text = DOMUtils.GetNonBlankTextOrFail(e);
BooleanQuery bq = new BooleanQuery(DOMUtils.GetAttribute(e, "disableCoord", false));
bq.MinimumNumberShouldMatch = DOMUtils.GetAttribute(e, "minimumNumberShouldMatch", 0);
TokenStream ts = null;
try
{
ts = analyzer.TokenStream(fieldName, text);
ITermToBytesRefAttribute termAtt = ts.AddAttribute<ITermToBytesRefAttribute>();
Term term = null;
BytesRef bytes = termAtt.BytesRef;
ts.Reset();
while (ts.IncrementToken())
{
termAtt.FillBytesRef();
term = new Term(fieldName, BytesRef.DeepCopyOf(bytes));
bq.Add(new BooleanClause(new TermQuery(term), BooleanClause.Occur.SHOULD));
}
ts.End();
}
catch (IOException ioe)
{
throw new Exception("Error constructing terms from index:" + ioe);
}
finally
{
IOUtils.CloseWhileHandlingException(ts);
}
bq.Boost = DOMUtils.GetAttribute(e, "boost", 1.0f);
return bq;
}
/// <summary> Create a new FuzzyQuery that will match terms with a similarity
/// of at least <c>minimumSimilarity</c> to <c>term</c>.
/// If a <c>prefixLength</c> > 0 is specified, a common prefix
/// of that length is also required.
///
/// </summary>
/// <param name="term">the term to search for
/// </param>
/// <param name="minimumSimilarity">a value between 0 and 1 to set the required similarity
/// between the query term and the matching terms. For example, for a
/// <c>minimumSimilarity</c> of <c>0.5</c> a term of the same length
/// as the query term is considered similar to the query term if the edit distance
/// between both terms is less than <c>length(term)*0.5</c>
/// </param>
/// <param name="prefixLength">length of common (non-fuzzy) prefix
/// </param>
/// <throws> IllegalArgumentException if minimumSimilarity is >= 1 or < 0 </throws>
/// <summary> or if prefixLength < 0
/// </summary>
public FuzzyQuery(Term term, float minimumSimilarity, int prefixLength)
{
this.Term = term;
if (minimumSimilarity >= 1.0f)
{
throw new System.ArgumentException("minimumSimilarity >= 1");
}
else if (minimumSimilarity < 0.0f)
{
throw new System.ArgumentException("minimumSimilarity < 0");
}
if (prefixLength < 0)
{
throw new System.ArgumentException("prefixLength < 0");
}
if (term.Text.Length > 1.0f / (1.0f - minimumSimilarity))
{
this.termLongEnough = true;
}
this.minimumSimilarity = minimumSimilarity;
this.prefixLength = prefixLength;
internalRewriteMethod = SCORING_BOOLEAN_QUERY_REWRITE;
}
private void AddMetaDataField(Document doc, Term term, int[] meta)
{
IntMetaDataTokenStream tokenStream = new IntMetaDataTokenStream(term.Text);
tokenStream.SetMetaData(meta);
Field field = new Field(term.Field, tokenStream);
doc.Add(field);
}
protected void AddNumericRangeQuery(BooleanQuery query, NumericRangeField range, BooleanClause.Occur occurance)
{
var startTerm = new Term(range.FieldName, SearchHelper.FormatNumber(range.Start));
var endTerm = new Term(range.FieldName, SearchHelper.FormatNumber(range.End));
var rangeQuery = new RangeQuery(startTerm, endTerm, true);
query.Add(rangeQuery, occurance);
}
public virtual void Test()
{
Term allTerm = new Term(FIELD, "all");
TermQuery termQuery = new TermQuery(allTerm);
Weight weight = IndexSearcher.CreateNormalizedWeight(termQuery);
Assert.IsTrue(IndexSearcher.TopReaderContext is AtomicReaderContext);
AtomicReaderContext context = (AtomicReaderContext)IndexSearcher.TopReaderContext;
BulkScorer ts = weight.BulkScorer(context, true, ((AtomicReader)context.Reader()).LiveDocs);
// we have 2 documents with the term all in them, one document for all the
// other values
IList<TestHit> docs = new List<TestHit>();
// must call next first
ts.Score(new CollectorAnonymousInnerClassHelper(this, context, docs));
Assert.IsTrue(docs.Count == 2, "docs Size: " + docs.Count + " is not: " + 2);
TestHit doc0 = docs[0];
TestHit doc5 = docs[1];
// The scores should be the same
Assert.IsTrue(doc0.Score == doc5.Score, doc0.Score + " does not equal: " + doc5.Score);
/*
* Score should be (based on Default Sim.: All floats are approximate tf = 1
* numDocs = 6 docFreq(all) = 2 idf = ln(6/3) + 1 = 1.693147 idf ^ 2 =
* 2.8667 boost = 1 lengthNorm = 1 //there is 1 term in every document coord
* = 1 sumOfSquaredWeights = (idf * boost) ^ 2 = 1.693147 ^ 2 = 2.8667
* queryNorm = 1 / (sumOfSquaredWeights)^0.5 = 1 /(1.693147) = 0.590
*
* score = 1 * 2.8667 * 1 * 1 * 0.590 = 1.69
*/
Assert.IsTrue(doc0.Score == 1.6931472f, doc0.Score + " does not equal: " + 1.6931472f);
}
protected internal override string[] CreateValue(IndexReader reader, Entry entryKey, IState state)
{
System.String field = StringHelper.Intern(entryKey.field);
System.String[] retArray = new System.String[reader.MaxDoc];
TermDocs termDocs = reader.TermDocs(state);
TermEnum termEnum = reader.Terms(new Term(field), state);
try
{
do
{
Term term = termEnum.Term;
if (term == null || (System.Object)term.Field != (System.Object)field)
{
break;
}
System.String termval = term.Text;
termDocs.Seek(termEnum, state);
while (termDocs.Next(state))
{
retArray[termDocs.Doc] = termval;
}
}while (termEnum.Next(state));
}
finally
{
termDocs.Close();
termEnum.Close();
}
return(retArray);
}
public virtual void TestSimpleSkip()
{
Directory dir = new CountingRAMDirectory(this, new RAMDirectory());
IndexWriter writer = new IndexWriter(dir, NewIndexWriterConfig(TEST_VERSION_CURRENT, new PayloadAnalyzer()).SetCodec(TestUtil.AlwaysPostingsFormat(new Lucene41PostingsFormat())).SetMergePolicy(NewLogMergePolicy()));
Term term = new Term("test", "a");
for (int i = 0; i < 5000; i++)
{
Document d1 = new Document();
d1.Add(NewTextField(term.Field(), term.Text(), Field.Store.NO));
writer.AddDocument(d1);
}
writer.Commit();
writer.ForceMerge(1);
writer.Dispose();
AtomicReader reader = GetOnlySegmentReader(DirectoryReader.Open(dir));
for (int i = 0; i < 2; i++)
{
Counter = 0;
DocsAndPositionsEnum tp = reader.TermPositionsEnum(term);
CheckSkipTo(tp, 14, 185); // no skips
CheckSkipTo(tp, 17, 190); // one skip on level 0
CheckSkipTo(tp, 287, 200); // one skip on level 1, two on level 0
// this test would fail if we had only one skip level,
// because than more bytes would be read from the freqStream
CheckSkipTo(tp, 4800, 250); // one skip on level 2
}
}
/// <summary>
/// Create a new <see cref="SlowFuzzyQuery"/> that will match terms with a similarity
/// of at least <paramref name="minimumSimilarity"/> to <paramref name="term"/>.
/// If a <paramref name="prefixLength"/> > 0 is specified, a common prefix
/// of that length is also required.
/// </summary>
/// <param name="term">the term to search for</param>
/// <param name="minimumSimilarity">
/// a value between 0 and 1 to set the required similarity
/// between the query term and the matching terms. For example, for a
/// <paramref name="minimumSimilarity"/> of <c>0.5</c> a term of the same length
/// as the query term is considered similar to the query term if the edit distance
/// between both terms is less than <c>length(term)*0.5</c>
/// <para/>
/// Alternatively, if <paramref name="minimumSimilarity"/> is >= 1f, it is interpreted
/// as a pure Levenshtein edit distance. For example, a value of <c>2f</c>
/// will match all terms within an edit distance of <c>2</c> from the
/// query term. Edit distances specified in this way may not be fractional.
/// </param>
/// <param name="prefixLength">length of common (non-fuzzy) prefix</param>
/// <param name="maxExpansions">
/// the maximum number of terms to match. If this number is
/// greater than <see cref="BooleanQuery.MaxClauseCount"/> when the query is rewritten,
/// then the maxClauseCount will be used instead.
/// </param>
/// <exception cref="ArgumentException">
/// if <paramref name="minimumSimilarity"/> is >= 1 or < 0
/// or if <paramref name="prefixLength"/> < 0
/// </exception>
public SlowFuzzyQuery(Term term, float minimumSimilarity, int prefixLength,
int maxExpansions)
: base(term.Field)
{
this.term = term;
if (minimumSimilarity >= 1.0f && minimumSimilarity != (int)minimumSimilarity)
throw new ArgumentException("fractional edit distances are not allowed");
if (minimumSimilarity < 0.0f)
throw new ArgumentException("minimumSimilarity < 0");
if (prefixLength < 0)
throw new ArgumentException("prefixLength < 0");
if (maxExpansions < 0)
throw new ArgumentException("maxExpansions < 0");
SetRewriteMethod(new MultiTermQuery.TopTermsScoringBooleanQueryRewrite(maxExpansions));
string text = term.Text();
int len = text.CodePointCount(0, text.Length);
if (len > 0 && (minimumSimilarity >= 1f || len > 1.0f / (1.0f - minimumSimilarity)))
{
this.termLongEnough = true;
}
this.minimumSimilarity = minimumSimilarity;
this.prefixLength = prefixLength;
}
public void AndExtension()
{
BooleanQuery originalQuery = new BooleanQuery();
BooleanQuery innerQuery = new BooleanQuery();
Term term = new Term("_name", "value1");
TermQuery termQuery1 = new TermQuery(term);
innerQuery.Add(termQuery1, Occur.MUST);
Term term2 = new Term("_name", "value2");
TermQuery termQuery2 = new TermQuery(term2);
innerQuery.Add(termQuery2, Occur.MUST);
originalQuery.Add(innerQuery, Occur.MUST);
string queryString = originalQuery.ToString();
QueryBuilder builder = new QueryBuilder();
builder.And
(
x => x.Term("_name", "value1"),
x => x.Term("_name", "value2")
);
Query replacementQuery = builder.Build();
string newQueryString = replacementQuery.ToString();
Assert.AreEqual(queryString, newQueryString);
Console.Write(queryString);
}
public static Lucene.Net.Search.Query FilterQueryByClasses(IESI.ISet<System.Type> classesAndSubclasses, Lucene.Net.Search.Query luceneQuery)
{
// A query filter is more practical than a manual class filtering post query (esp on scrollable resultsets)
// it also probably minimise the memory footprint
if (classesAndSubclasses == null)
{
return luceneQuery;
}
BooleanQuery classFilter = new BooleanQuery();
// annihilate the scoring impact of DocumentBuilder.CLASS_FIELDNAME
classFilter.SetBoost(0);
foreach (System.Type clazz in classesAndSubclasses)
{
Term t = new Term(DocumentBuilder.CLASS_FIELDNAME, TypeHelper.LuceneTypeName(clazz));
TermQuery termQuery = new TermQuery(t);
classFilter.Add(termQuery, BooleanClause.Occur.SHOULD);
}
BooleanQuery filteredQuery = new BooleanQuery();
filteredQuery.Add(luceneQuery, BooleanClause.Occur.MUST);
filteredQuery.Add(classFilter, BooleanClause.Occur.MUST);
return filteredQuery;
}
public void Read(IndexInput input, FieldInfos fieldInfos)
{
this.term = null; // invalidate cache
int start = input.ReadVInt();
int length = input.ReadVInt();
int totalLength = start + length;
if (preUTF8Strings)
{
text.SetLength(totalLength);
input.ReadChars(text.result, start, length);
}
else
{
if (dirty)
{
// Fully convert all bytes since bytes is dirty
UnicodeUtil.UTF16toUTF8(text.result, 0, text.length, bytes);
bytes.SetLength(totalLength);
input.ReadBytes(bytes.result, start, length);
UnicodeUtil.UTF8toUTF16(bytes.result, 0, totalLength, text);
dirty = false;
}
else
{
// Incrementally convert only the UTF8 bytes that are new:
bytes.SetLength(totalLength);
input.ReadBytes(bytes.result, start, length);
UnicodeUtil.UTF8toUTF16(bytes.result, start, length, text);
}
}
this.field = fieldInfos.FieldName(input.ReadVInt());
}
/// <summary>macro for readability </summary>
public static Query Cspq(Term prefix)
{
PrefixQuery query = new PrefixQuery(prefix);
query.RewriteMethod = MultiTermQuery.CONSTANT_SCORE_FILTER_REWRITE;
return(query);
}
public void UpdatePackage(Package package)
{
var packageRegistrationKey = package.PackageRegistrationKey;
var updateTerm = new Term("PackageRegistrationKey", packageRegistrationKey.ToString(CultureInfo.InvariantCulture));
if (!package.IsLatest || package.IsLatestStable)
{
// Someone passed us in a version which was e.g. just unlisted? Or just not the latest version which is what we want to index. Doesn't really matter. We'll find one to index.
package = _packageRepository.GetAll()
.Where(p => (p.IsLatest || p.IsLatestStable) && p.PackageRegistrationKey == packageRegistrationKey)
.Include(p => p.PackageRegistration)
.Include(p => p.PackageRegistration.Owners)
.Include(p => p.SupportedFrameworks)
.FirstOrDefault();
}
// Just update the provided package
using (Trace.Activity(String.Format(CultureInfo.CurrentCulture, "Updating Lucene Index for: {0} {1} [PackageKey:{2}]", package.PackageRegistration.Id, package.Version, package.Key)))
{
EnsureIndexWriter(creatingIndex: false);
if (package != null)
{
var indexEntity = new PackageIndexEntity(package);
Trace.Information(String.Format(CultureInfo.CurrentCulture, "Updating Document: {0}", updateTerm.ToString()));
_indexWriter.UpdateDocument(updateTerm, indexEntity.ToDocument());
}
else
{
Trace.Information(String.Format(CultureInfo.CurrentCulture, "Deleting Document: {0}", updateTerm.ToString()));
_indexWriter.DeleteDocuments(updateTerm);
}
_indexWriter.Commit();
}
}
protected void AddNumericRangeQuery(BooleanQuery query, NumericRangeField range, BooleanClause.Occur occurance)
{
var startTerm = new Term(range.FieldName, NumberTools.LongToString(range.Start));
var endTerm = new Term(range.FieldName, NumberTools.LongToString(range.End));
var rangeQuery = new RangeQuery(startTerm, endTerm, true);
query.Add(rangeQuery, occurance);
}
/// <summary>
/// Построение поискового индекса по полученным в результате синхронизации сообщениям
/// </summary>
public static int ProcessResponseMessages(IEnumerable<MessageSearchInfo> messages)
{
if (messages == null)
throw new ArgumentNullException("messages");
int addedCount;
var indexPath = GetIndexDir();
// Чистим
if (IndexReader.IndexExists(indexPath))
{
var reader = IndexReader.Open(indexPath, false);
var baseTerm = new Term("mid");
try
{
foreach (var msg in messages)
{
var term = baseTerm.CreateTerm(msg.MessageBody ?? "");
reader.DeleteDocuments(term);
}
}
finally
{
reader.Close();
}
}
//Добавляем
var writer = CreateIndexWriter();
try
{
var count = 0;
foreach (var msg in messages)
{
// Форумы с id 0 и 58 это мусорки
if (msg.ForumID == 0 || msg.ForumID == 58)
continue;
writer.AddDocument(
CreateDocument(
msg.MessageID.ToString(),
msg.ForumID.ToString(),
FormatDate(msg.MessageDate),
msg.Subject,
msg.UserID.ToString(),
msg.UserNick,
msg.MessageBody));
count++;
}
addedCount = count;
}
finally
{
writer.Close();
}
return addedCount;
}
protected internal override float[] CreateValue(IndexReader reader, Entry entryKey, IState state)
{
Entry entry = entryKey;
System.String field = entry.field;
FloatParser parser = (FloatParser)entry.custom;
if (parser == null)
{
try
{
return(wrapper.GetFloats(reader, field, Lucene.Net.Search.FieldCache_Fields.DEFAULT_FLOAT_PARSER, state));
}
catch (System.FormatException)
{
return(wrapper.GetFloats(reader, field, Lucene.Net.Search.FieldCache_Fields.NUMERIC_UTILS_FLOAT_PARSER, state));
}
}
float[] retArray = null;
TermDocs termDocs = reader.TermDocs(state);
TermEnum termEnum = reader.Terms(new Term(field), state);
try
{
do
{
Term term = termEnum.Term;
if (term == null || (System.Object)term.Field != (System.Object)field)
{
break;
}
float termval = parser.ParseFloat(term.Text);
if (retArray == null)
{
// late init
retArray = new float[reader.MaxDoc];
}
termDocs.Seek(termEnum, state);
while (termDocs.Next(state))
{
retArray[termDocs.Doc] = termval;
}
}while (termEnum.Next(state));
}
catch (StopFillCacheException)
{
}
finally
{
termDocs.Close();
termEnum.Close();
}
if (retArray == null)
{
// no values
retArray = new float[reader.MaxDoc];
}
return(retArray);
}
protected override IEnumerable<Term> VisitTerm(Term term)
{
yield return term;
var chars = term.Text.ToCharArray();
Array.Reverse(chars);
yield return new Term(term.Field, new string(chars));
}
public MultiValueFacetHandler(string name, string indexFieldName, TermListFactory termListFactory, Term sizePayloadTerm, IEnumerable<string> depends)
: base(name, depends)
{
_depends = depends;
_indexFieldName = (indexFieldName != null ? indexFieldName : name);
_termListFactory = termListFactory;
_sizePayloadTerm = sizePayloadTerm;
_dataCache = null;
}
public static TermQuery Term(this BooleanQuery inputQuery, string fieldName, string fieldValue, BooleanClause.Occur occur = null)
{
Term term = new Term(fieldName, fieldValue);
BooleanQuery parentQuery = GetParentQuery(inputQuery);
TermQuery query = new TermQuery(term);
SetOccurValue(inputQuery, ref occur);
parentQuery.Add(query, occur);
return query;
}
protected int getHitCount(String fieldName, String searchString)
{
IndexSearcher searcher = new IndexSearcher(directory, true); //4
Term t = new Term(fieldName, searchString);
Query query = new TermQuery(t); //5
int hitCount = TestUtil.hitCount(searcher, query); //6
searcher.Close();
return hitCount;
}
/// <summary> Creates a new <c>MultipleTermPositions</c> instance.
///
/// </summary>
/// <exception cref="System.IO.IOException">
/// </exception>
public MultipleTermPositions(IndexReader indexReader, Term[] terms)
{
System.Collections.IList termPositions = new System.Collections.ArrayList();
for (int i = 0; i < terms.Length; i++)
termPositions.Add(indexReader.TermPositions(terms[i]));
_termPositionsQueue = new TermPositionsQueue(termPositions);
_posList = new IntQueue();
}
public override int GetHashCode()
{
int prime = 31;
int result = base.GetHashCode();
result = prime * result + BitConverter.ToInt32(BitConverter.GetBytes(minimumSimilarity), 0);
result = prime * result + prefixLength;
result = prime * result + ((Term == null)?0:Term.GetHashCode());
return(result);
}
public virtual void TestSetBufferSize()
{
System.IO.DirectoryInfo indexDir = new System.IO.DirectoryInfo(System.IO.Path.Combine(AppSettings.Get("tempDir", ""), "testSetBufferSize"));
MockFSDirectory dir = new MockFSDirectory(indexDir, NewRandom());
try
{
IndexWriter writer = new IndexWriter(dir, new WhitespaceAnalyzer(), true, IndexWriter.MaxFieldLength.LIMITED, null);
writer.UseCompoundFile = false;
for (int i = 0; i < 37; i++)
{
Document doc = new Document();
doc.Add(new Field("content", "aaa bbb ccc ddd" + i, Field.Store.YES, Field.Index.ANALYZED));
doc.Add(new Field("id", "" + i, Field.Store.YES, Field.Index.ANALYZED));
writer.AddDocument(doc, null);
}
writer.Close();
dir.allIndexInputs.Clear();
IndexReader reader = IndexReader.Open((Directory)dir, false, null);
Term aaa = new Term("content", "aaa");
Term bbb = new Term("content", "bbb");
Term ccc = new Term("content", "ccc");
Assert.AreEqual(37, reader.DocFreq(ccc, null));
reader.DeleteDocument(0, null);
Assert.AreEqual(37, reader.DocFreq(aaa, null));
dir.tweakBufferSizes();
reader.DeleteDocument(4, null);
Assert.AreEqual(reader.DocFreq(bbb, null), 37);
dir.tweakBufferSizes();
IndexSearcher searcher = new IndexSearcher(reader);
ScoreDoc[] hits = searcher.Search(new TermQuery(bbb), null, 1000, null).ScoreDocs;
dir.tweakBufferSizes();
Assert.AreEqual(35, hits.Length);
dir.tweakBufferSizes();
hits = searcher.Search(new TermQuery(new Term("id", "33")), null, 1000, null).ScoreDocs;
dir.tweakBufferSizes();
Assert.AreEqual(1, hits.Length);
hits = searcher.Search(new TermQuery(aaa), null, 1000, null).ScoreDocs;
dir.tweakBufferSizes();
Assert.AreEqual(35, hits.Length);
searcher.Close();
reader.Close();
}
finally
{
_TestUtil.RmDir(indexDir);
}
}
private static bool LowPrecisionNumber(Lucene.Net.Index.Term term)
{
if (term.Field.EndsWith("_Range") == false)
{
return(false);
}
if (string.IsNullOrEmpty(term.Text))
{
return(false);
}
return(term.Text[0] - NumericUtils.SHIFT_START_INT != 0 &&
term.Text[0] - NumericUtils.SHIFT_START_LONG != 0);
}
protected internal override short[] CreateValue(IndexReader reader, Entry entryKey, IState state)
{
Entry entry = entryKey;
System.String field = entry.field;
ShortParser parser = (ShortParser)entry.custom;
if (parser == null)
{
return(wrapper.GetShorts(reader, field, Lucene.Net.Search.FieldCache_Fields.DEFAULT_SHORT_PARSER, state));
}
short[] retArray = new short[reader.MaxDoc];
TermDocs termDocs = reader.TermDocs(state);
TermEnum termEnum = reader.Terms(new Term(field), state);
try
{
do
{
Term term = termEnum.Term;
if (term == null || (System.Object)term.Field != (System.Object)field)
{
break;
}
short termval = parser.ParseShort(term.Text);
termDocs.Seek(termEnum, state);
while (termDocs.Next(state))
{
retArray[termDocs.Doc] = termval;
}
}while (termEnum.Next(state));
}
catch (StopFillCacheException)
{
}
finally
{
termDocs.Close();
termEnum.Close();
}
return(retArray);
}
public override bool Equals(System.Object obj)
{
if (this == obj)
{
return(true);
}
if (!base.Equals(obj))
{
return(false);
}
if (GetType() != obj.GetType())
{
return(false);
}
FuzzyQuery other = (FuzzyQuery)obj;
if (BitConverter.ToInt32(BitConverter.GetBytes(minimumSimilarity), 0) != BitConverter.ToInt32(BitConverter.GetBytes(other.minimumSimilarity), 0))
{
return(false);
}
if (prefixLength != other.prefixLength)
{
return(false);
}
if (Term == null)
{
if (other.Term != null)
{
return(false);
}
}
else if (!Term.Equals(other.Term))
{
return(false);
}
return(true);
}
public JsonDocumentDto Retrieve(BaristaIndexDefinition indexDefinition, string documentId)
{
if (documentId.IsNullOrWhiteSpace())
{
throw new ArgumentNullException("documentId", @"A document Id must be specified.");
}
try
{
var index = GetOrAddIndex(indexDefinition, true);
IndexSearcher indexSearcher;
using (index.GetSearcher(out indexSearcher))
{
var term = new Lucene.Net.Index.Term(Constants.DocumentIdFieldName, documentId.ToLowerInvariant());
var termQuery = new Lucene.Net.Search.TermQuery(term);
var hits = indexSearcher.Search(termQuery, 1);
if (hits.TotalHits == 0)
{
return(null);
}
var result = RetrieveSearchResults(indexSearcher, hits).FirstOrDefault();
return(result == null
? null
: result.Document);
}
}
catch (Exception ex)
{
throw new FaultException(ex.Message);
}
}
public PKIndexSplitter(Directory input, Directory dir1, Directory dir2, Term midTerm, IndexWriterConfig config1, IndexWriterConfig config2)
: this(input, dir1, dir2, new TermRangeFilter(midTerm.Field, null, midTerm.Bytes, true, false), config1, config2)
{
}
public override Query Rewrite(IndexReader reader, IState state)
{
if (!termLongEnough)
{
// can only match if it's exact
return(new TermQuery(Term));
}
int maxSize = BooleanQuery.MaxClauseCount;
// TODO: Java uses a PriorityQueue. Using Linq, we can emulate it,
// however it's considerable slower than the java counterpart.
// this should be a temporary thing, fixed before release
SortedList <ScoreTerm, ScoreTerm> stQueue = new SortedList <ScoreTerm, ScoreTerm>();
FilteredTermEnum enumerator = GetEnum(reader, state);
try
{
ScoreTerm st = new ScoreTerm();
do
{
Term t = enumerator.Term;
if (t == null)
{
break;
}
float score = enumerator.Difference();
//ignore uncompetetive hits
if (stQueue.Count >= maxSize && score <= stQueue.Keys.First().score)
{
continue;
}
// add new entry in PQ
st.term = t;
st.score = score;
stQueue.Add(st, st);
// possibly drop entries from queue
if (stQueue.Count > maxSize)
{
st = stQueue.Keys.First();
stQueue.Remove(st);
}
else
{
st = new ScoreTerm();
}
}while (enumerator.Next(state));
}
finally
{
enumerator.Close();
}
BooleanQuery query = new BooleanQuery(true);
foreach (ScoreTerm st in stQueue.Keys)
{
TermQuery tq = new TermQuery(st.term); // found a match
tq.Boost = Boost * st.score; // set the boost
query.Add(tq, Occur.SHOULD); // add to query
}
return(query);
}
/// <summary> Calls <see cref="FuzzyQuery(Index.Term, float)">FuzzyQuery(term, 0.5f, 0)</see>.</summary>
public FuzzyQuery(Term term) : this(term, defaultMinSimilarity, defaultPrefixLength)
{
}
/// <summary> Calls <see cref="FuzzyQuery(Index.Term, float)">FuzzyQuery(term, minimumSimilarity, 0)</see>.</summary>
public FuzzyQuery(Term term, float minimumSimilarity) : this(term, minimumSimilarity, defaultPrefixLength)
{
}
// inherit javadoc
public override int DocFreq(Term term, IState state)
{
return(reader.DocFreq(term, state));
}
public virtual void TestRollingUpdates_Mem()
{
Random random = new Random(Random().Next());
BaseDirectoryWrapper dir = NewDirectory();
LineFileDocs docs = new LineFileDocs(random, DefaultCodecSupportsDocValues());
//provider.register(new MemoryCodec());
// LUCENE TODO: uncomment this out once MemoryPostingsFormat is brought over
//if ((!"Lucene3x".Equals(Codec.Default.Name)) && Random().NextBoolean())
//{
// Codec.Default =
// TestUtil.AlwaysPostingsFormat(new MemoryPostingsFormat(random().nextBoolean(), random.NextFloat()));
//}
MockAnalyzer analyzer = new MockAnalyzer(Random());
analyzer.MaxTokenLength = TestUtil.NextInt(Random(), 1, IndexWriter.MAX_TERM_LENGTH);
IndexWriter w = new IndexWriter(dir, NewIndexWriterConfig(TEST_VERSION_CURRENT, analyzer));
int SIZE = AtLeast(20);
int id = 0;
IndexReader r = null;
IndexSearcher s = null;
int numUpdates = (int)(SIZE * (2 + (TEST_NIGHTLY ? 200 * Random().NextDouble() : 5 * Random().NextDouble())));
if (VERBOSE)
{
Console.WriteLine("TEST: numUpdates=" + numUpdates);
}
int updateCount = 0;
// TODO: sometimes update ids not in order...
for (int docIter = 0; docIter < numUpdates; docIter++)
{
Documents.Document doc = docs.NextDoc();
string myID = "" + id;
if (id == SIZE - 1)
{
id = 0;
}
else
{
id++;
}
if (VERBOSE)
{
Console.WriteLine(" docIter=" + docIter + " id=" + id);
}
((Field)doc.GetField("docid")).StringValue = myID;
Term idTerm = new Term("docid", myID);
bool doUpdate;
if (s != null && updateCount < SIZE)
{
TopDocs hits = s.Search(new TermQuery(idTerm), 1);
Assert.AreEqual(1, hits.TotalHits);
doUpdate = !w.TryDeleteDocument(r, hits.ScoreDocs[0].Doc);
if (VERBOSE)
{
if (doUpdate)
{
Console.WriteLine(" tryDeleteDocument failed");
}
else
{
Console.WriteLine(" tryDeleteDocument succeeded");
}
}
}
else
{
doUpdate = true;
if (VERBOSE)
{
Console.WriteLine(" no searcher: doUpdate=true");
}
}
updateCount++;
if (doUpdate)
{
w.UpdateDocument(idTerm, doc);
}
else
{
w.AddDocument(doc);
}
if (docIter >= SIZE && Random().Next(50) == 17)
{
if (r != null)
{
r.Dispose();
}
bool applyDeletions = Random().NextBoolean();
if (VERBOSE)
{
Console.WriteLine("TEST: reopen applyDeletions=" + applyDeletions);
}
r = w.GetReader(applyDeletions);
if (applyDeletions)
{
s = NewSearcher(r);
}
else
{
s = null;
}
Assert.IsTrue(!applyDeletions || r.NumDocs == SIZE, "applyDeletions=" + applyDeletions + " r.NumDocs=" + r.NumDocs + " vs SIZE=" + SIZE);
updateCount = 0;
}
}
if (r != null)
{
r.Dispose();
}
w.Commit();
Assert.AreEqual(SIZE, w.NumDocs());
w.Dispose();
TestIndexWriter.AssertNoUnreferencedFiles(dir, "leftover files after rolling updates");
docs.Dispose();
// LUCENE-4455:
SegmentInfos infos = new SegmentInfos();
infos.Read(dir);
long totalBytes = 0;
foreach (SegmentCommitInfo sipc in infos.Segments)
{
totalBytes += sipc.SizeInBytes();
}
long totalBytes2 = 0;
foreach (string fileName in dir.ListAll())
{
if (!fileName.StartsWith(IndexFileNames.SEGMENTS))
{
totalBytes2 += dir.FileLength(fileName);
}
}
Assert.AreEqual(totalBytes2, totalBytes);
dir.Dispose();
}
public virtual void DeleteDocuments(Term term) => IndexWriter.DeleteDocuments(term);
public virtual void TestDeleteLeftoverFiles()
{
Directory dir = new RAMDirectory();
IndexWriter writer = new IndexWriter(dir, new WhitespaceAnalyzer(), true, IndexWriter.MaxFieldLength.LIMITED, null);
writer.SetMaxBufferedDocs(10);
int i;
for (i = 0; i < 35; i++)
{
AddDoc(writer, i);
}
writer.UseCompoundFile = false;
for (; i < 45; i++)
{
AddDoc(writer, i);
}
writer.Close();
// Delete one doc so we get a .del file:
IndexReader reader = IndexReader.Open(dir, false, null);
Term searchTerm = new Term("id", "7");
int delCount = reader.DeleteDocuments(searchTerm, null);
Assert.AreEqual(1, delCount, "didn't delete the right number of documents");
// Set one norm so we get a .s0 file:
reader.SetNorm(21, "content", (float)1.5, null);
reader.Close();
// Now, artificially create an extra .del file & extra
// .s0 file:
System.String[] files = dir.ListAll(null);
/*
* for(int j=0;j<files.length;j++) {
* System.out.println(j + ": " + files[j]);
* }
*/
// The numbering of fields can vary depending on which
// JRE is in use. On some JREs we see content bound to
// field 0; on others, field 1. So, here we have to
// figure out which field number corresponds to
// "content", and then set our expected file names below
// accordingly:
CompoundFileReader cfsReader = new CompoundFileReader(dir, "_2.cfs", null);
FieldInfos fieldInfos = new FieldInfos(cfsReader, "_2.fnm", null);
int contentFieldIndex = -1;
for (i = 0; i < fieldInfos.Size(); i++)
{
FieldInfo fi = fieldInfos.FieldInfo(i);
if (fi.name_ForNUnit.Equals("content"))
{
contentFieldIndex = i;
break;
}
}
cfsReader.Close();
Assert.IsTrue(contentFieldIndex != -1, "could not locate the 'content' field number in the _2.cfs segment");
System.String normSuffix = "s" + contentFieldIndex;
// Create a bogus separate norms file for a
// segment/field that actually has a separate norms file
// already:
CopyFile(dir, "_2_1." + normSuffix, "_2_2." + normSuffix);
// Create a bogus separate norms file for a
// segment/field that actually has a separate norms file
// already, using the "not compound file" extension:
CopyFile(dir, "_2_1." + normSuffix, "_2_2.f" + contentFieldIndex);
// Create a bogus separate norms file for a
// segment/field that does not have a separate norms
// file already:
CopyFile(dir, "_2_1." + normSuffix, "_1_1." + normSuffix);
// Create a bogus separate norms file for a
// segment/field that does not have a separate norms
// file already using the "not compound file" extension:
CopyFile(dir, "_2_1." + normSuffix, "_1_1.f" + contentFieldIndex);
// Create a bogus separate del file for a
// segment that already has a separate del file:
CopyFile(dir, "_0_1.del", "_0_2.del");
// Create a bogus separate del file for a
// segment that does not yet have a separate del file:
CopyFile(dir, "_0_1.del", "_1_1.del");
// Create a bogus separate del file for a
// non-existent segment:
CopyFile(dir, "_0_1.del", "_188_1.del");
// Create a bogus segment file:
CopyFile(dir, "_0.cfs", "_188.cfs");
// Create a bogus fnm file when the CFS already exists:
CopyFile(dir, "_0.cfs", "_0.fnm");
// Create a deletable file:
CopyFile(dir, "_0.cfs", "deletable");
// Create some old segments file:
CopyFile(dir, "segments_3", "segments");
CopyFile(dir, "segments_3", "segments_2");
// Create a bogus cfs file shadowing a non-cfs segment:
CopyFile(dir, "_2.cfs", "_3.cfs");
System.String[] filesPre = dir.ListAll(null);
// Open & close a writer: it should delete the above 4
// files and nothing more:
writer = new IndexWriter(dir, new WhitespaceAnalyzer(), false, IndexWriter.MaxFieldLength.LIMITED, null);
writer.Close();
System.String[] files2 = dir.ListAll(null);
dir.Close();
System.Array.Sort(files);
System.Array.Sort(files2);
System.Collections.Hashtable dif = DifFiles(files, files2);
if (!CollectionsHelper.Equals(files, files2))
{
Assert.Fail("IndexFileDeleter failed to delete unreferenced extra files: should have deleted " + (filesPre.Length - files.Length) + " files but only deleted " + (filesPre.Length - files2.Length) + "; expected files:\n " + AsString(files) + "\n actual files:\n " + AsString(files2) + "\ndif: " + CollectionsHelper.CollectionToString(dif));
}
}
/// <summary> Compares if current upper bound is reached,
/// this also updates the term count for statistics.
/// In contrast to <see cref="FilteredTermEnum" />, a return value
/// of <c>false</c> ends iterating the current enum
/// and forwards to the next sub-range.
/// </summary>
//@Override
protected internal override bool TermCompare(Term term)
{
return(term.Field == Enclosing_Instance.field && string.CompareOrdinal(term.Text, currentUpperBound) <= 0);
}
private void InitBlock(NumericRangeQuery <T> enclosingInstance)
{
this.enclosingInstance = enclosingInstance;
termTemplate = new Term(Enclosing_Instance.field);
}
public override TermEnum Terms(Term term)
{
EnsureOpen();
return(new MultiTermEnum(this, subReaders, starts, term));
}
public virtual void TestEmptyIndex()
{
// creating two directories for indices
Directory indexStoreA = new MockRAMDirectory();
Directory indexStoreB = new MockRAMDirectory();
// creating a document to store
Document lDoc = new Document();
lDoc.Add(new Field("fulltext", "Once upon a time.....", Field.Store.YES, Field.Index.ANALYZED));
lDoc.Add(new Field("id", "doc1", Field.Store.YES, Field.Index.NOT_ANALYZED));
lDoc.Add(new Field("handle", "1", Field.Store.YES, Field.Index.NOT_ANALYZED));
// creating a document to store
Document lDoc2 = new Document();
lDoc2.Add(new Field("fulltext", "in a galaxy far far away.....", Field.Store.YES, Field.Index.ANALYZED));
lDoc2.Add(new Field("id", "doc2", Field.Store.YES, Field.Index.NOT_ANALYZED));
lDoc2.Add(new Field("handle", "1", Field.Store.YES, Field.Index.NOT_ANALYZED));
// creating a document to store
Document lDoc3 = new Document();
lDoc3.Add(new Field("fulltext", "a bizarre bug manifested itself....", Field.Store.YES, Field.Index.ANALYZED));
lDoc3.Add(new Field("id", "doc3", Field.Store.YES, Field.Index.NOT_ANALYZED));
lDoc3.Add(new Field("handle", "1", Field.Store.YES, Field.Index.NOT_ANALYZED));
// creating an index writer for the first index
IndexWriter writerA = new IndexWriter(indexStoreA, new StandardAnalyzer(Util.Version.LUCENE_CURRENT), true, IndexWriter.MaxFieldLength.LIMITED, null);
// creating an index writer for the second index, but writing nothing
IndexWriter writerB = new IndexWriter(indexStoreB, new StandardAnalyzer(Util.Version.LUCENE_CURRENT), true, IndexWriter.MaxFieldLength.LIMITED, null);
//--------------------------------------------------------------------
// scenario 1
//--------------------------------------------------------------------
// writing the documents to the first index
writerA.AddDocument(lDoc, null);
writerA.AddDocument(lDoc2, null);
writerA.AddDocument(lDoc3, null);
writerA.Optimize(null);
writerA.Close();
// closing the second index
writerB.Close();
// creating the query
QueryParser parser = new QueryParser(Util.Version.LUCENE_CURRENT, "fulltext", new StandardAnalyzer(Util.Version.LUCENE_CURRENT));
Query query = parser.Parse("handle:1");
// building the searchables
Searcher[] searchers = new Searcher[2];
// VITAL STEP:adding the searcher for the empty index first, before the searcher for the populated index
searchers[0] = new IndexSearcher(indexStoreB, true, null);
searchers[1] = new IndexSearcher(indexStoreA, true, null);
// creating the multiSearcher
Searcher mSearcher = GetMultiSearcherInstance(searchers);
// performing the search
ScoreDoc[] hits = mSearcher.Search(query, null, 1000, null).ScoreDocs;
Assert.AreEqual(3, hits.Length);
// iterating over the hit documents
for (int i = 0; i < hits.Length; i++)
{
mSearcher.Doc(hits[i].Doc, null);
}
mSearcher.Close();
//--------------------------------------------------------------------
// scenario 2
//--------------------------------------------------------------------
// adding one document to the empty index
writerB = new IndexWriter(indexStoreB, new StandardAnalyzer(Util.Version.LUCENE_CURRENT), false, IndexWriter.MaxFieldLength.LIMITED, null);
writerB.AddDocument(lDoc, null);
writerB.Optimize(null);
writerB.Close();
// building the searchables
Searcher[] searchers2 = new Searcher[2];
// VITAL STEP:adding the searcher for the empty index first, before the searcher for the populated index
searchers2[0] = new IndexSearcher(indexStoreB, true, null);
searchers2[1] = new IndexSearcher(indexStoreA, true, null);
// creating the mulitSearcher
MultiSearcher mSearcher2 = GetMultiSearcherInstance(searchers2);
// performing the same search
ScoreDoc[] hits2 = mSearcher2.Search(query, null, 1000, null).ScoreDocs;
Assert.AreEqual(4, hits2.Length);
// iterating over the hit documents
for (int i = 0; i < hits2.Length; i++)
{
// no exception should happen at this point
mSearcher2.Doc(hits2[i].Doc, null);
}
// test the subSearcher() method:
Query subSearcherQuery = parser.Parse("id:doc1");
hits2 = mSearcher2.Search(subSearcherQuery, null, 1000, null).ScoreDocs;
Assert.AreEqual(2, hits2.Length);
Assert.AreEqual(0, mSearcher2.SubSearcher(hits2[0].Doc)); // hit from searchers2[0]
Assert.AreEqual(1, mSearcher2.SubSearcher(hits2[1].Doc)); // hit from searchers2[1]
subSearcherQuery = parser.Parse("id:doc2");
hits2 = mSearcher2.Search(subSearcherQuery, null, 1000, null).ScoreDocs;
Assert.AreEqual(1, hits2.Length);
Assert.AreEqual(1, mSearcher2.SubSearcher(hits2[0].Doc)); // hit from searchers2[1]
mSearcher2.Close();
//--------------------------------------------------------------------
// scenario 3
//--------------------------------------------------------------------
// deleting the document just added, this will cause a different exception to take place
Term term = new Term("id", "doc1");
IndexReader readerB = IndexReader.Open(indexStoreB, false, null);
readerB.DeleteDocuments(term, null);
readerB.Close();
// optimizing the index with the writer
writerB = new IndexWriter(indexStoreB, new StandardAnalyzer(Util.Version.LUCENE_CURRENT), false, IndexWriter.MaxFieldLength.LIMITED, null);
writerB.Optimize(null);
writerB.Close();
// building the searchables
Searcher[] searchers3 = new Searcher[2];
searchers3[0] = new IndexSearcher(indexStoreB, true, null);
searchers3[1] = new IndexSearcher(indexStoreA, true, null);
// creating the mulitSearcher
Searcher mSearcher3 = GetMultiSearcherInstance(searchers3);
// performing the same search
ScoreDoc[] hits3 = mSearcher3.Search(query, null, 1000, null).ScoreDocs;
Assert.AreEqual(3, hits3.Length);
// iterating over the hit documents
for (int i = 0; i < hits3.Length; i++)
{
mSearcher3.Doc(hits3[i].Doc, null);
}
mSearcher3.Close();
indexStoreA.Close();
indexStoreB.Close();
}
/// <summary>
/// Split an index based on a given primary key term
/// and a 'middle' term. If the middle term is present, it's
/// sent to dir2.
/// </summary>
public PKIndexSplitter(LuceneVersion version, Directory input, Directory dir1, Directory dir2, Term midTerm)
: this(version, input, dir1, dir2, new TermRangeFilter(midTerm.Field, null, midTerm.Bytes, true, false))
{
}
public virtual void UpdateBinaryDocValue(Term term, string field, BytesRef value) => IndexWriter.UpdateBinaryDocValue(term, field, value);
public virtual void UpdateNumericDocValue(Term term, string field, long?value) => IndexWriter.UpdateNumericDocValue(term, field, value);
public virtual void UpdateDocuments(Term delTerm, IEnumerable <IEnumerable <IIndexableField> > docs)
{
IndexWriter.UpdateDocuments(delTerm, docs);
MaybeCommit();
}
public PayloadTermQuery(Term term, PayloadFunction function)
: this(term, function, true)
{
}
public PayloadTermQuery(Term term, PayloadFunction function, bool includeSpanScore)
: base(term)
{
this.Function = function;
this.IncludeSpanScore = includeSpanScore;
}