public void SynonymTest()
{
var indexWriter = new IndexWriter(new RAMDirectory(), _contentAnalyzer, IndexWriter.MaxFieldLength.UNLIMITED);
AddDocument(indexWriter, "This device is HDTV compatible.");
AddDocument(indexWriter, "Purchasing officer");
indexWriter.commit();
var indexSearcher = new IndexSearcher(indexWriter.getReader());
var query = _queryParser.parse("hdtv");
var hits = indexSearcher.search(query, 10);
Assert.AreEqual(1, hits.totalHits);
query = _queryParser.parse("high definition television");
hits = indexSearcher.search(query, 10);
Assert.AreEqual(1, hits.totalHits);
query = _queryParser.parse("television");
hits = indexSearcher.search(query, 10);
Assert.AreEqual(1, hits.totalHits);
query = _queryParser.parse("\"high definition television\"");
hits = indexSearcher.search(query, 10);
Assert.AreEqual(1, hits.totalHits);
// Case 11017 "Purchasing Officer" returned while searching for "Technical coordinator".
query = _queryParser.parse("Technical coordinator");
hits = indexSearcher.search(query, 10);
Assert.AreEqual(0, hits.totalHits);
}
public void StemmerTest()
{
var indexWriter = new IndexWriter(new RAMDirectory(), _contentAnalyzer, IndexWriter.MaxFieldLength.UNLIMITED);
AddDocument(indexWriter, "All our accountants and lawyers are busy at the moment");
indexWriter.commit();
var indexSearcher = new IndexSearcher(indexWriter.getReader());
var query = _queryParser.parse("Accountant");
var hits = indexSearcher.search(query, 10);
Assert.AreEqual(1, hits.totalHits);
query = _queryParser.parse("account");
hits = indexSearcher.search(query, 10);
Assert.AreEqual(0, hits.totalHits);
query = _queryParser.parse("Lawyers");
hits = indexSearcher.search(query, 10);
Assert.AreEqual(1, hits.totalHits);
query = _queryParser.parse("Lawyer");
hits = indexSearcher.search(query, 10);
Assert.AreEqual(1, hits.totalHits);
}
/*
* This shows how to construct a phrase query containing shingles.
*/
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void testShingleAnalyzerWrapperPhraseQuery() throws Exception
public virtual void testShingleAnalyzerWrapperPhraseQuery()
{
PhraseQuery q = new PhraseQuery();
TokenStream ts = analyzer.tokenStream("content", "this sentence");
try
{
int j = -1;
PositionIncrementAttribute posIncrAtt = ts.addAttribute(typeof(PositionIncrementAttribute));
CharTermAttribute termAtt = ts.addAttribute(typeof(CharTermAttribute));
ts.reset();
while (ts.incrementToken())
{
j += posIncrAtt.PositionIncrement;
string termText = termAtt.ToString();
q.add(new Term("content", termText), j);
}
ts.end();
}
finally
{
IOUtils.closeWhileHandlingException(ts);
}
ScoreDoc[] hits = searcher.search(q, null, 1000).scoreDocs;
int[] ranks = new int[] { 0 };
compareRanks(hits, ranks);
}
static public void query(Sentence[] sentences, string query, string indexPath = "luceneIndex")
{
Dictionary <string, Sentence> map = new Dictionary <string, Sentence>();
foreach (Sentence s in sentences)
{
if (!map.ContainsKey(s.sentnece))
{
map.Add(s.sentnece, s);
}
}
java.io.File indexDir = new java.io.File(indexPath);
FSDirectory indexFSDir = new SimpleFSDirectory(indexDir);
IndexSearcher searcher = new IndexSearcher(IndexReader.open(indexFSDir));
EnglishAnalyzer luceneAnalyzer = new EnglishAnalyzer(org.apache.lucene.util.Version.LUCENE_35);
QueryParser qp = new QueryParser(org.apache.lucene.util.Version.LUCENE_35, "text", luceneAnalyzer);
Query q = qp.parse(query);
TopDocs tdocs = searcher.search(q, 99999999);
ScoreDoc[] sdocs = tdocs.scoreDocs;
for (int i = 0; i < sdocs.Length; i++)
{
ScoreDoc sd = sdocs[i];
Document res = searcher.doc(sd.doc);
string docText = res.get("text");
float score = sd.score;
map[docText].lucene = score;
}
searcher.close();
}
private ICollection <EntityId> InternalQuery(Query query, QueryContext contextOrNull)
{
if (this._directory == null)
{
return(Collections.emptySet());
}
try
{
Sort sorting = contextOrNull != null ? contextOrNull.Sorting : null;
bool prioritizeCorrectness = contextOrNull == null || !contextOrNull.TradeCorrectnessForSpeed;
IndexSearcher theSearcher = Searcher(prioritizeCorrectness);
query = IncludeOrphans(query);
DocValuesCollector docValuesCollector = new DocValuesCollector(prioritizeCorrectness);
theSearcher.search(query, docValuesCollector);
ICollection <EntityId> result = new List <EntityId>();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.eclipse.collections.api.iterator.LongIterator valuesIterator = docValuesCollector.getSortedValuesIterator(KEY_DOC_ID, sorting);
LongIterator valuesIterator = docValuesCollector.GetSortedValuesIterator(KEY_DOC_ID, sorting);
while (valuesIterator.hasNext())
{
result.Add(new EntityId_IdData(valuesIterator.next()));
}
return(result);
}
catch (IOException e)
{
throw new Exception(e);
}
}
private DateTime?GetMetaTimestamp()
{
var indexSearcher = new IndexSearcher(_indexWriter.getReader());
// Find "meta" document.
var query = new TermQuery(MetaDocIdTerm);
var hits = indexSearcher.search(query, 1);
if (hits.totalHits == 0)
{
return(null);
}
// Get "meta" document timestamp.
var metaDoc = indexSearcher.doc(hits.scoreDocs[0].doc);
var timestamp = metaDoc.get(SearchFieldName.Timestamp);
if (string.IsNullOrEmpty(timestamp))
{
return(null);
}
return(new DateTime(long.Parse(timestamp)));
}
private void DoTest(Random random, PrintWriter @out, bool useCompoundFiles, int MAX_DOCS)
{
Directory directory = newDirectory();
Analyzer analyzer = new MockAnalyzer(random);
IndexWriterConfig conf = newIndexWriterConfig(TEST_VERSION_CURRENT, analyzer);
MergePolicy mp = conf.MergePolicy;
mp.NoCFSRatio = useCompoundFiles ? 1.0 : 0.0;
IndexWriter writer = new IndexWriter(directory, conf);
if (VERBOSE)
{
Console.WriteLine("TEST: now build index MAX_DOCS=" + MAX_DOCS);
}
for (int j = 0; j < MAX_DOCS; j++)
{
Document d = new Document();
d.Add(newTextField(PRIORITY_FIELD, HIGH_PRIORITY, Field.Store.YES));
d.Add(newTextField(ID_FIELD, Convert.ToString(j), Field.Store.YES));
writer.addDocument(d);
}
writer.Dispose();
// try a search without OR
IndexReader reader = DirectoryReader.Open(directory);
IndexSearcher searcher = newSearcher(reader);
Query query = new TermQuery(new Term(PRIORITY_FIELD, HIGH_PRIORITY));
@out.println("Query: " + query.ToString(PRIORITY_FIELD));
if (VERBOSE)
{
Console.WriteLine("TEST: search query=" + query);
}
Sort sort = new Sort(SortField.FIELD_SCORE, new SortField(ID_FIELD, SortField.Type.INT));
ScoreDoc[] hits = searcher.Search(query, null, MAX_DOCS, sort).scoreDocs;
PrintHits(@out, hits, searcher);
CheckHits(hits, MAX_DOCS, searcher);
// try a new search with OR
searcher = newSearcher(reader);
hits = null;
BooleanQuery booleanQuery = new BooleanQuery();
booleanQuery.Add(new TermQuery(new Term(PRIORITY_FIELD, HIGH_PRIORITY)), BooleanClause.Occur_e.SHOULD);
booleanQuery.Add(new TermQuery(new Term(PRIORITY_FIELD, MED_PRIORITY)), BooleanClause.Occur_e.SHOULD);
@out.println("Query: " + booleanQuery.ToString(PRIORITY_FIELD));
hits = searcher.search(booleanQuery, null, MAX_DOCS, sort).scoreDocs;
PrintHits(@out, hits, searcher);
CheckHits(hits, MAX_DOCS, searcher);
reader.Close();
directory.Close();
}
public virtual void TestDemo()
{
Analyzer analyzer = new MockAnalyzer(random());
// Store the index in memory:
Directory directory = newDirectory();
// To store an index on disk, use this instead:
// Directory directory = FSDirectory.open(new File("/tmp/testindex"));
RandomIndexWriter iwriter = new RandomIndexWriter(random(), directory, analyzer);
Document doc = new Document();
string longTerm = "longtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongterm";
string text = "this is the text to be indexed. " + longTerm;
doc.add(newTextField("fieldname", text, Field.Store.YES));
iwriter.addDocument(doc);
iwriter.close();
// Now search the index:
IndexReader ireader = DirectoryReader.open(directory); // read-only=true
IndexSearcher isearcher = newSearcher(ireader);
Assert.AreEqual(1, isearcher.search(new TermQuery(new Term("fieldname", longTerm)), 1).totalHits);
Query query = new TermQuery(new Term("fieldname", "text"));
TopDocs hits = isearcher.search(query, null, 1);
Assert.AreEqual(1, hits.totalHits);
// Iterate through the results:
for (int i = 0; i < hits.scoreDocs.length; i++)
{
Document hitDoc = isearcher.doc(hits.scoreDocs[i].doc);
Assert.AreEqual(text, hitDoc.get("fieldname"));
}
// Test simple phrase query
PhraseQuery phraseQuery = new PhraseQuery();
phraseQuery.add(new Term("fieldname", "to"));
phraseQuery.add(new Term("fieldname", "be"));
Assert.AreEqual(1, isearcher.search(phraseQuery, null, 1).totalHits);
ireader.close();
directory.close();
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public static java.util.List<long> getAllNodes(org.apache.lucene.store.Directory directory, org.neo4j.values.storable.Value propertyValue) throws java.io.IOException
public static IList <long> GetAllNodes(Directory directory, Value propertyValue)
{
using (SearcherManager manager = new SearcherManager(directory, new SearcherFactory()))
{
IndexSearcher searcher = manager.acquire();
Query query = LuceneDocumentStructure.NewSeekQuery(propertyValue);
AllNodesCollector collector = new AllNodesCollector();
searcher.search(query, collector);
return(collector._nodeIds);
}
}
private TopDocs Search(IndexSearcher indexSearcher, string queryString)
{
var query = _queryParser.parse(queryString);
Console.WriteLine();
Console.WriteLine(queryString);
Console.WriteLine(query.toString());
var hits = indexSearcher.search(query, 10);
return(hits);
}
public void PunctuationTest()
{
var indexWriter = new IndexWriter(new RAMDirectory(), _contentAnalyzer, IndexWriter.MaxFieldLength.UNLIMITED);
AddDocument(indexWriter, "One, two.Three");
indexWriter.commit();
var indexSearcher = new IndexSearcher(indexWriter.getReader());
var query = _queryParser.parse("one");
var hits = indexSearcher.search(query, 10);
Assert.AreEqual(1, hits.totalHits);
query = _queryParser.parse("two");
hits = indexSearcher.search(query, 10);
Assert.AreEqual(1, hits.totalHits);
query = _queryParser.parse("three");
hits = indexSearcher.search(query, 10);
Assert.AreEqual(1, hits.totalHits);
}
private DocValuesCollector Search(Query query)
{
try
{
DocValuesCollector docValuesCollector = new DocValuesCollector();
IndexSearcher.search(query, docValuesCollector);
return(docValuesCollector);
}
catch (IOException e)
{
throw new Exception(e);
}
}
private static Guid[] Search(MemberSearchQuery memberQuery)
{
var query = _indexer.GetQuery(memberQuery);
var filter = _indexer.GetFilter(memberQuery, null, null);
var hits = _indexSearcher.search(query, filter, 10);
return(Array.ConvertAll(hits.scoreDocs, scoreDoc =>
{
var document = _indexSearcher.doc(scoreDoc.doc);
return new Guid(document.get(SearchFieldName.Id));
}));
}
private ScoreEntityIterator IndexQuery(Query query)
{
try
{
DocValuesCollector docValuesCollector = new DocValuesCollector(true);
IndexSearcher.search(query, docValuesCollector);
ValuesIterator sortedValuesIterator = docValuesCollector.GetSortedValuesIterator(LuceneFulltextDocumentStructure.FIELD_ENTITY_ID, Sort.RELEVANCE);
return(new ScoreEntityIterator(sortedValuesIterator));
}
catch (IOException e)
{
throw new Exception(e);
}
}
public virtual void TestNegativeQueryBoost()
{
Query q = new TermQuery(new Term("foo", "bar"));
q.Boost = -42f;
Assert.AreEqual(-42f, q.Boost, 0.0f);
Directory directory = newDirectory();
try
{
Analyzer analyzer = new MockAnalyzer(random());
IndexWriterConfig conf = newIndexWriterConfig(TEST_VERSION_CURRENT, analyzer);
IndexWriter writer = new IndexWriter(directory, conf);
try
{
Document d = new Document();
d.add(newTextField("foo", "bar", Field.Store.YES));
writer.addDocument(d);
}
finally
{
writer.close();
}
IndexReader reader = DirectoryReader.open(directory);
try
{
IndexSearcher searcher = newSearcher(reader);
ScoreDoc[] hits = searcher.search(q, null, 1000).scoreDocs;
Assert.AreEqual(1, hits.Length);
Assert.IsTrue("score is not negative: " + hits[0].score, hits[0].score < 0);
Explanation explain = searcher.explain(q, hits[0].doc);
Assert.AreEqual("score doesn't match explanation", hits[0].score, explain.Value, 0.001f);
Assert.IsTrue("explain doesn't think doc is a match", explain.Match);
}
finally
{
reader.close();
}
}
finally
{
directory.close();
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private org.apache.lucene.search.TopDocs toTopDocs(org.apache.lucene.search.Query query, org.neo4j.index.lucene.QueryContext context, org.apache.lucene.search.IndexSearcher searcher) throws java.io.IOException
private TopDocs ToTopDocs(Query query, QueryContext context, IndexSearcher searcher)
{
Sort sorting = context != null ? context.Sorting : null;
TopDocs topDocs;
if (sorting == null && context != null)
{
topDocs = searcher.search(query, context.Top);
}
else
{
if (context == null || !context.TradeCorrectnessForSpeed)
{
TopFieldCollector collector = LuceneDataSource.ScoringCollector(sorting, context.Top);
searcher.search(query, collector);
topDocs = collector.topDocs();
}
else
{
topDocs = searcher.search(query, null, context.Top, sorting);
}
}
return(topDocs);
}
internal static Document FindDocument(IndexType type, IndexSearcher searcher, long entityId)
{
try
{
TopDocs docs = searcher.search(type.IdTermQuery(entityId), 1);
if (docs.scoreDocs.length > 0)
{
return(searcher.doc(docs.scoreDocs[0].doc));
}
return(null);
}
catch (IOException e)
{
throw new Exception(e);
}
}
private void DoTestSearch(Random random, PrintWriter @out, bool useCompoundFile)
{
Directory directory = newDirectory();
Analyzer analyzer = new MockAnalyzer(random);
IndexWriterConfig conf = newIndexWriterConfig(TEST_VERSION_CURRENT, analyzer);
MergePolicy mp = conf.MergePolicy;
mp.NoCFSRatio = useCompoundFile ? 1.0 : 0.0;
IndexWriter writer = new IndexWriter(directory, conf);
string[] docs = new string[] { "a b c d e", "a b c d e a b c d e", "a b c d e f g h i j", "a c e", "e c a", "a c e a c e", "a c e a b c" };
for (int j = 0; j < docs.Length; j++)
{
Document d = new Document();
d.add(newTextField("contents", docs[j], Field.Store.YES));
d.add(newStringField("id", "" + j, Field.Store.NO));
writer.addDocument(d);
}
writer.close();
IndexReader reader = DirectoryReader.open(directory);
IndexSearcher searcher = newSearcher(reader);
ScoreDoc[] hits = null;
Sort sort = new Sort(SortField.FIELD_SCORE, new SortField("id", SortField.Type.INT));
foreach (Query query in BuildQueries())
{
@out.println("Query: " + query.ToString("contents"));
if (VERBOSE)
{
Console.WriteLine("TEST: query=" + query);
}
hits = searcher.search(query, null, 1000, sort).scoreDocs;
@out.println(hits.Length + " total results");
for (int i = 0; i < hits.Length && i < 10; i++)
{
Document d = searcher.doc(hits[i].doc);
@out.println(i + " " + hits[i].score + " " + d.get("contents"));
}
}
reader.close();
directory.close();
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void assertIndexedValues(Hit... expectedHits) throws java.io.IOException
private void AssertIndexedValues(params Hit[] expectedHits)
{
SwitchToVerification();
foreach (Hit hit in expectedHits)
{
TopDocs hits = _searcher.search(LuceneDocumentStructure.NewSeekQuery(hit.Value), 10);
assertEquals(hit.NodeIds.Length, hits.totalHits, "Unexpected number of index results from " + hit.Value);
ISet <long> foundNodeIds = new HashSet <long>();
for (int i = 0; i < hits.totalHits; i++)
{
Document document = _searcher.doc(hits.scoreDocs[i].doc);
foundNodeIds.Add(parseLong(document.get("id")));
}
assertEquals(asSet(hit.NodeIds), foundNodeIds);
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private org.eclipse.collections.api.set.primitive.LongSet gatherIdsModifiedInTransactionState(java.util.List<EntityId> simpleTransactionStateIds, org.apache.lucene.search.IndexSearcher fulltextTransactionStateSearcher, org.apache.lucene.search.Query query) throws java.io.IOException
private LongSet GatherIdsModifiedInTransactionState(IList <EntityId> simpleTransactionStateIds, IndexSearcher fulltextTransactionStateSearcher, Query query)
{
// If there's no state them don't bother gathering it
if (simpleTransactionStateIds.Count == 0 && fulltextTransactionStateSearcher == null)
{
return(LongSets.immutable.empty());
}
// There's potentially some state
DocValuesCollector docValuesCollector = null;
int fulltextSize = 0;
if (fulltextTransactionStateSearcher != null)
{
docValuesCollector = new DocValuesCollector();
fulltextTransactionStateSearcher.search(query, docValuesCollector);
fulltextSize = docValuesCollector.TotalHits;
// Nah, no state
if (simpleTransactionStateIds.Count == 0 && fulltextSize == 0)
{
return(LongSets.immutable.empty());
}
}
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.eclipse.collections.api.set.primitive.MutableLongSet set = new org.eclipse.collections.impl.set.mutable.primitive.LongHashSet(simpleTransactionStateIds.size() + fulltextSize);
MutableLongSet set = new LongHashSet(simpleTransactionStateIds.Count + fulltextSize);
// Add from simple tx state
foreach (EntityId id in simpleTransactionStateIds)
{
set.add(id.Id());
}
if (docValuesCollector != null)
{
// Add from fulltext tx state
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.eclipse.collections.api.iterator.LongIterator valuesIterator = docValuesCollector.getValuesIterator(LuceneExplicitIndex.KEY_DOC_ID);
LongIterator valuesIterator = docValuesCollector.GetValuesIterator(LuceneExplicitIndex.KEY_DOC_ID);
while (valuesIterator.hasNext())
{
set.add(valuesIterator.next());
}
}
return(set);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void letThroughAdditions(org.apache.lucene.search.IndexSearcher additionsSearcher, org.apache.lucene.search.Query query, java.util.Collection<EntityId> removed) throws java.io.IOException
private void LetThroughAdditions(IndexSearcher additionsSearcher, Query query, ICollection <EntityId> removed)
{
// This could be improved further by doing a term-dict lookup for every term in removed
// and retaining only those that did not match.
// This is getting quite low-level though
DocValuesCollector collector = new DocValuesCollector(false);
additionsSearcher.search(query, collector);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.eclipse.collections.api.iterator.LongIterator valuesIterator = collector.getValuesIterator(KEY_DOC_ID);
LongIterator valuesIterator = collector.GetValuesIterator(KEY_DOC_ID);
LongCostume id = new LongCostume();
while (valuesIterator.hasNext())
{
long value = valuesIterator.next();
removed.remove(id.setId(value));
}
}
static void SearchForPhrase(IndexSearcher searcher, string phrase)
{
using (new AutoStopWatch(string.Format("Search for {0}", phrase)))
{
var parser = new QueryParser(org.apache.lucene.util.Version.LUCENE_CURRENT, "Body", new StandardAnalyzer(org.apache.lucene.util.Version.LUCENE_CURRENT));
Query query = parser.parse(phrase);
var hits = searcher.search(query, 100);
Console.WriteLine("Found {0} results for {1}", hits.totalHits, phrase);
int max = hits.totalHits;
if (max > 100)
{
max = 100;
}
for (int i = 0; i < max; i++)
{
Console.WriteLine(hits.scoreDocs[i].doc);
}
}
}
public override long CountIndexedNodes(long nodeId, int[] propertyKeyIds, params Value[] propertyValues)
{
Query nodeIdQuery = new TermQuery(LuceneDocumentStructure.newTermForChangeOrRemove(nodeId));
Query valueQuery = LuceneDocumentStructure.newSeekQuery(propertyValues);
BooleanQuery.Builder nodeIdAndValueQuery = (new BooleanQuery.Builder()).setDisableCoord(true);
nodeIdAndValueQuery.add(nodeIdQuery, BooleanClause.Occur.MUST);
nodeIdAndValueQuery.add(valueQuery, BooleanClause.Occur.MUST);
try
{
TotalHitCountCollector collector = new TotalHitCountCollector();
IndexSearcher.search(nodeIdAndValueQuery.build(), collector);
// A <label,propertyKeyId,nodeId> tuple should only match at most a single propertyValue
return(collector.TotalHits);
}
catch (IOException e)
{
throw new Exception(e);
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public void verify(org.neo4j.storageengine.api.NodePropertyAccessor accessor, int[] propKeyIds) throws org.neo4j.kernel.api.exceptions.index.IndexEntryConflictException, java.io.IOException
public override void Verify(NodePropertyAccessor accessor, int[] propKeyIds)
{
try
{
DuplicateCheckingCollector collector = DuplicateCheckingCollector.ForProperties(accessor, propKeyIds);
IndexSearcher searcher = IndexSearcher();
foreach (LeafReaderContext leafReaderContext in searcher.IndexReader.leaves())
{
Fields fields = leafReaderContext.reader().fields();
foreach (string field in fields)
{
if (LuceneDocumentStructure.useFieldForUniquenessVerification(field))
{
TermsEnum terms = LuceneDocumentStructure.originalTerms(fields.terms(field), field);
BytesRef termsRef;
while ((termsRef = terms.next()) != null)
{
if (terms.docFreq() > 1)
{
collector.Init(terms.docFreq());
searcher.search(new TermQuery(new Term(field, termsRef)), collector);
}
}
}
}
}
}
catch (IOException e)
{
Exception cause = e.InnerException;
if (cause is IndexEntryConflictException)
{
throw ( IndexEntryConflictException )cause;
}
throw e;
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void removeFromCache(long entityId) throws java.io.IOException
private void RemoveFromCache(long entityId)
{
IndexSearcher searcher = _searcherManager.acquire();
try
{
Query query = _type.idTermQuery(entityId);
TopDocs docs = searcher.search(query, 1);
if (docs.totalHits > 0)
{
Document document = searcher.doc(docs.scoreDocs[0].doc);
foreach (IndexableField field in document.Fields)
{
string key = field.name();
object value = field.stringValue();
RemoveFromCache(entityId, key, value);
}
}
}
finally
{
_searcherManager.release(searcher);
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private org.neo4j.graphdb.index.IndexHits<org.apache.lucene.document.Document> search(IndexReference searcherRef, org.apache.lucene.search.IndexSearcher fulltextTransactionStateSearcher, org.apache.lucene.search.Query query, org.neo4j.index.lucene.QueryContext additionalParametersOrNull, java.util.Collection<EntityId> removed) throws java.io.IOException
private IndexHits <Document> Search(IndexReference searcherRef, IndexSearcher fulltextTransactionStateSearcher, Query query, QueryContext additionalParametersOrNull, ICollection <EntityId> removed)
{
if (fulltextTransactionStateSearcher != null && removed.Count > 0)
{
LetThroughAdditions(fulltextTransactionStateSearcher, query, removed);
}
IndexSearcher searcher = fulltextTransactionStateSearcher == null ? searcherRef.Searcher : new IndexSearcher(new MultiReader(searcherRef.Searcher.IndexReader, fulltextTransactionStateSearcher.IndexReader));
IndexHits <Document> result;
if (additionalParametersOrNull != null && additionalParametersOrNull.Top > 0)
{
result = new TopDocsIterator(query, additionalParametersOrNull, searcher);
}
else
{
Sort sorting = additionalParametersOrNull != null ? additionalParametersOrNull.Sorting : null;
bool forceScore = additionalParametersOrNull == null || !additionalParametersOrNull.TradeCorrectnessForSpeed;
DocValuesCollector collector = new DocValuesCollector(forceScore);
searcher.search(query, collector);
return(collector.GetIndexHits(sorting));
}
return(result);
}
public void IndexFolder(string folderName)
{
IDictionary<string,JToken> exifInfo = null;
var didAddFiles = false;
string[] allFilenames;
try
{
allFilenames = System.IO.Directory.GetFiles(folderName);
}
catch (Exception ex)
{
logger.Error(String.Format("Exception getting filenames from {0}: {1}", folderName, ex));
return;
}
foreach (var filename in allFilenames)
{
try
{
if (mainReader.Value == null)
{
mainReader.Value = DirectoryReader.open(mainWriter.getDirectory());
}
CheckForCommit(mainWriter);
Interlocked.Increment(ref fileNumber);
if ((FileNumber % 100) == 0)
{
var seconds = (DateTime.Now - startTime).TotalSeconds;
logger.Debug("Processed {0} files in {1:N0} seconds ({2:N2} files/second); processing {3}",
FileNumber,
seconds,
FileNumber / seconds,
filename);
}
if (!FileTypes.IsSupportedFilename(filename))
continue;
string hashValue = CalculateHash(filename);
var query = new BooleanQuery();
var fileInfo = new FileInfo(filename);
query.add(new TermQuery(new Term(FieldName.SignatureIndexPath, indexPreferences.ToIndexPath(filename))), BooleanClause.Occur.MUST);
var searcher = new IndexSearcher(mainReader.Value);
var results = searcher.search(query, 1);
if (results.totalHits > 0)
{
var existingDoc = searcher.doc(results.scoreDocs[0].doc);
// Skip this file? - no changes since it was last indexed
if (IsCurrent(existingDoc, filename, hashValue, fileInfo.Length))
{
// Ensure a thumbnail exists for this file
thumbnailIndexer.CheckThumbnail(
filename,
existingDoc.get(FieldName.MimeType),
existingDoc.get(FieldName.Size));
continue;
}
var deleteQuery = new BooleanQuery();
deleteQuery.add(new TermQuery(new Term(FieldName.SignatureIndexPath, indexPreferences.ToIndexPath(filename))), BooleanClause.Occur.MUST);
mainWriter.deleteDocuments(deleteQuery);
}
if (exifInfo == null)
{
try
{
exifInfo = BatchExifTool(folderName);
}
catch (Exception e)
{
logger.Warn("Skipping '{0}' due to exif failure: {1}", Path.GetDirectoryName(filename), e.Message);
break;
}
}
var exifSourceFile = filename;
foreach (var folderPrefix in Preferences.Instance.FoldersToWatch)
exifSourceFile = exifSourceFile.Replace(folderPrefix, "");
JToken exif;
exifInfo.TryGetValue(exifSourceFile.ToLower().Replace('\\', '/'), out exif);
var doc = new Document();
if (ProcessFile(filename, doc, hashValue, exif))
{
var facetsConfig = FindAPhoto.Common.Facets.FacetsConfig;
mainWriter.addDocument(facetsConfig.build(taxonomyWriter, doc));
++FilesAdded;
didAddFiles = true;
MadeChange();
}
}
catch (Exception ex)
{
logger.Error(String.Format("Exception handling file {0}: {1}", filename, ex));
}
}
// Added files aren't visible to this instance of the reader; the search won't detect them until a new
// reader is opened. On the other hand, opening a reader after each addition is quite expensive.
if (didAddFiles)
{
mainReader.Value.close();
mainReader.Value = null;
}
}
static void SearchForPhrase(IndexSearcher searcher, string phrase)
{
using (new AutoStopWatch(string.Format("Search for {0}", phrase)))
{
var parser = new QueryParser(org.apache.lucene.util.Version.LUCENE_CURRENT, "Body", new StandardAnalyzer(org.apache.lucene.util.Version.LUCENE_CURRENT));
Query query = parser.parse(phrase);
var hits = searcher.search(query, 100);
Console.WriteLine("Found {0} results for {1}", hits.totalHits, phrase);
int max = hits.totalHits;
if (max > 100)
max = 100;
for (int i = 0; i < max; i++)
{
Console.WriteLine(hits.scoreDocs[i].doc);
}
}
}
private bool Load(IndexSearcher searcher)
{
var query = new BooleanQuery();
query.add(new TermQuery(new Term(PreferencesDocumentField, PreferencesName)), BooleanClause.Occur.MUST);
nextFolderId = 1;
var results = searcher.search(query, 1);
if (results.totalHits > 0)
{
var doc = searcher.doc(results.scoreDocs[0].doc);
if (doc.get(RegisteredFoldersField) != null)
{
var prefs = JsonConvert.DeserializeObject<FolderPreferences>(doc.get(RegisteredFoldersField));
nextFolderId = prefs.NextFolderId;
foreach (var fm in prefs.FolderMapping)
registeredFolders.Add(fm.Id, fm.Path);
return true;
}
}
return false;
}
