private static IEnumerable<CustomerId> _search(string searchQuery)
{
// validation
if (string.IsNullOrEmpty(searchQuery.Replace("*", "").Replace("?", ""))) return new List<CustomerId>();
// set up lucene searcher
using (var searcher = new IndexSearcher(_directory, false))
{
var hits_limit = 1000;
var analyzer = new StandardAnalyzer(Version.LUCENE_29);
{
//var query = new TermQuery(new Term("CustomerName", searchQuery));
var query = new BooleanQuery();
query.Add(new TermQuery(new Term("CustomerName", searchQuery)), Occur.MUST);
var hits = searcher.Search(query, hits_limit).ScoreDocs;
var results = _mapLuceneToDataList(hits, searcher);
analyzer.Close();
searcher.Dispose();
return results;
}
}
}
public static LuceneResult SearchBIMXchange(string field, string key, int pageSize, int pageNumber)
{
const string luceneIndexPath = "C:\\LuceneIndex";
var directory = FSDirectory.Open(new DirectoryInfo(luceneIndexPath));
var analyzer = new StandardAnalyzer(Version.LUCENE_29);
var parser = new QueryParser(Version.LUCENE_29, field, analyzer);
var query = parser.Parse(String.Format("{0}*", key));
var searcher = new IndexSearcher(directory, true);
var topDocs = searcher.Search(query, 1000000);
var docs = new List<Document>();
var start = (pageNumber-1)*pageSize;
for (var i = start; i < start + pageSize && i < topDocs.TotalHits; i++)
{
var scoreDoc = topDocs.ScoreDocs[i];
var docId = scoreDoc.doc;
var doc = searcher.Doc(docId);
docs.Add(doc);
}
searcher.Close();
directory.Close();
var result = new LuceneResult {Results = docs, TotalCount = topDocs.TotalHits};
return result;
}
private void button1_Click(object sender, EventArgs e)
{
Directory index = new RAMDirectory();
StandardAnalyzer analyzer = new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_29);
IndexWriter w = new IndexWriter(index, analyzer);
addDoc(w, "Lucene in Action");
addDoc(w, "Lucene for Dummies");
addDoc(w, "Managing Gigabytes");
addDoc(w, "The Art of Computer Science");
w.Close();
String querystr = "Lucene in Action";
Query q = new QueryParser(Lucene.Net.Util.Version.LUCENE_29, "title", analyzer).Parse(querystr);
//q.Parse();
int hitsPerPage = 10;
IndexReader reader = IndexReader.Open(index,true);
IndexSearcher searcher = new IndexSearcher(reader);
TopScoreDocCollector collector = TopScoreDocCollector.Create(hitsPerPage, true);
searcher.Search(q, collector);
ScoreDoc[] hits = collector.TopDocs().ScoreDocs;
System.Console.WriteLine("Found {0} Hits", hits.Length);
foreach (var item in hits)
{
int docId = item.Doc;
Document d = searcher.Doc(docId);
System.Console.WriteLine(d.Get("title") + " " + item.Score);
}
}
// add/update/clear search index data
public static void AddUpdateLuceneIndex()
{
using (var context = new CreativeNetworkEntities())
{
// init lucene
var analyzer = new StandardAnalyzer(Version.LUCENE_30);
using (var writer = new IndexWriter(_directory, analyzer, IndexWriter.MaxFieldLength.UNLIMITED))
{
// add data to lucene search index (replaces older entries if any)
foreach (var creative in context.Creative)
{
_addToLuceneIndex(creative, writer);
foreach (var chapter in creative.Chapter)
{
_addToLuceneIndex(chapter, writer);
}
}
// close handles
analyzer.Close();
writer.Dispose();
}
}
}
private Analyzer GetAnalyer(int type)
{
Analyzer analyzer;
string path =System.Configuration.ConfigurationSettings.AppSettings["Data"].ToString();
switch (type)
{
case 0:
analyzer=new StockFooAnalyzer(path);
break;
case 1:
analyzer = new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_CURRENT);
break;
case 2:
analyzer = new SimpleAnalyzer();
break;
case 3:
analyzer = new StopAnalyzer(Lucene.Net.Util.Version.LUCENE_CURRENT);
break;
case 4:
analyzer = new KeywordAnalyzer();
break;
case 5:
analyzer = new WhitespaceAnalyzer();
break;
default:
analyzer = new StockFooAnalyzer(path);
break;
}
return analyzer;
}
IEnumerable<string> Search(string textToFind)
{
var reader = IndexReader.Open(_ramDirectory, true);
var searcher = new IndexSearcher(reader);
var analyzer = new StandardAnalyzer(Version.LUCENE_29);
var parser = new MultiFieldQueryParser(Version.LUCENE_29, _searchFields, analyzer);
var query = parser.Parse(textToFind);
var collector = TopScoreDocCollector.create(100, true);
searcher.Search(query, collector);
var hits = collector.TopDocs().scoreDocs;
var foundKeys = new List<string>();
foreach (ScoreDoc scoreDoc in hits)
{
var document = searcher.Doc(scoreDoc.doc);
var key = document.Get(_keyField);
if (key != null && !foundKeys.Contains(key))
{
foundKeys.Add(key);
}
}
reader.Close();
searcher.Close();
analyzer.Close();
return foundKeys;
}
// main search method
private static IEnumerable<SampleData> _search(string searchQuery, string searchField = "") {
// validation
if (string.IsNullOrEmpty(searchQuery.Replace("*", "").Replace("?", ""))) return new List<SampleData>();
// set up lucene searcher
using (var searcher = new IndexSearcher(_directory, false)) {
var hits_limit = 1000;
var analyzer = new StandardAnalyzer(Version.LUCENE_29);
// search by single field
if (!string.IsNullOrEmpty(searchField)) {
var parser = new QueryParser(Version.LUCENE_29, searchField, analyzer);
var query = parseQuery(searchQuery, parser);
var hits = searcher.Search(query, hits_limit).ScoreDocs;
var results = _mapLuceneToDataList(hits, searcher);
analyzer.Close();
searcher.Close();
searcher.Dispose();
return results;
}
// search by multiple fields (ordered by RELEVANCE)
else {
var parser = new MultiFieldQueryParser
(Version.LUCENE_29, new[] {"Id", "Name", "Description"}, analyzer);
var query = parseQuery(searchQuery, parser);
var hits = searcher.Search(query, null, hits_limit, Sort.INDEXORDER).ScoreDocs;
var results = _mapLuceneToDataList(hits, searcher);
analyzer.Close();
searcher.Close();
searcher.Dispose();
return results;
}
}
}
public void CreateIndex(List<ISearchEntity> CreateEntities)
{
Analyzer analyzer = new StandardAnalyzer();
IndexWriter writer = new IndexWriter(ConfigElement.IndexDirectory, analyzer, true);
//第三个参数：是否重新创建索引，True 一律清空 重新建立 False 原有基础上增量添加索引
foreach (ISearchEntity IndexEntity in CreateEntities)
{
NewsModel news = (NewsModel)IndexEntity;
Document doc = new Document();
doc.Add(new Field("newsid", Convert.ToString(news.EntityIdentity), Field.Store.YES, Field.Index.UN_TOKENIZED));
doc.Add(new Field("title", Convert.ToString(news.Title), Field.Store.YES, Field.Index.UN_TOKENIZED));
doc.Add(new Field("content", Convert.ToString(news.Content), Field.Store.YES, Field.Index.TOKENIZED));
doc.Add(new Field("keywords", Convert.ToString(news.Keywords), Field.Store.YES, Field.Index.UN_TOKENIZED));
doc.Add(new Field("catepath", Convert.ToString(news.CategoryPath), Field.Store.YES, Field.Index.UN_TOKENIZED));
doc.Add(new Field("createtime", Convert.ToString(news.CreateTime), Field.Store.YES, Field.Index.UN_TOKENIZED));
writer.AddDocument(doc);
Console.WriteLine("created index for {0}:{1}", news.EntityIdentity, news.Title);
}
writer.Optimize();
writer.Close();
}
protected void BindLucene()
{
StandardAnalyzer analyzer = new Lucene.Net.Analysis.Standard.StandardAnalyzer();
IndexSearcher searcher = new IndexSearcher("C:\\Clients\\NWTD5.0.200\\SearchIndex\\eCommerceFramework\\CatalogEntryIndexer");
BooleanQuery boolQuery = new BooleanQuery();
boolQuery.Add(new TermQuery(new Term("_catalog", "NWTD")), BooleanClause.Occur.MUST);
Hits hits = searcher.Search(boolQuery, new Sort("TypeSort"));
DataTable dt = new DataTable();
dt.Columns.Add("Code");
dt.Columns.Add("Name");
dt.Columns.Add("TypeSort");
for (int hitIndex = 0; hitIndex < hits.Length() && hitIndex < 10; hitIndex++)
{
Document hitDocument = hits.Doc(hitIndex);
object[] param = new[] {
hitDocument.GetField("Code").StringValue(),
hitDocument.GetField("Name").StringValue(),
hitDocument.GetField("TypeSort").StringValue()
};
dt.Rows.Add(param);
}
this.gvLuceneSearchResults.DataSource = dt;
this.gvLuceneSearchResults.DataBind();
}
public override List<ISearchEntity> GetSearchResult(out int MatchCount)
{
Analyzer analyzer = new StandardAnalyzer();
IndexSearcher searcher = new IndexSearcher(searchInfo.ConfigElement.IndexDirectory);
MultiFieldQueryParser parserName = new MultiFieldQueryParser(new string[] { "title", "content", "keywords" }, analyzer);
Query queryName = parserName.Parse(searchInfo.QueryString);
Hits hits = searcher.Search(queryName);
List<ISearchEntity> ResultList = new List<ISearchEntity>();
for (int i = 0; i < hits.Length(); i++)
{
Document doc = hits.Doc(i);
ResultList.Add((ISearchEntity)new NewsModel()
{
EntityIdentity = Convert.ToInt32(doc.Get("newsid")),
Title = Convert.ToString(doc.Get("title")),
Content = Convert.ToString(doc.Get("content")),
Keywords = doc.Get("keywords")
});
}
searcher.Close();
MatchCount = hits.Length();
return ResultList;
}
private LuceneHighlightHelper()
{
Separator = "...";
MaxNumHighlights = 5;
HighlightAnalyzer = new StandardAnalyzer(_luceneVersion);
HighlightFormatter = new SimpleHTMLFormatter("", " ");
}
/// <summary>
/// 分词测试
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnCutWords_Click(object sender, EventArgs e)
{
this.txtWords.Text = "";
Lucene.Net.Analysis.Standard.StandardAnalyzer analyzer = new Lucene.Net.Analysis.Standard.StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30);
txtWords.Text = cutWords(this.textBox2.Text, PanGuAnalyzer); //盘古分词
txtWords2.Text = cutWords(this.textBox2.Text, analyzer); //自带标准分词
}
public LuceneWriter(string folder)
{
_folder = folder;
_indexDirectory = FSDirectory.Open(new DirectoryInfo(folder));
_standardAnalyzer = new StandardAnalyzer(Version.LUCENE_30);
_indexWriter = new IndexWriter(_indexDirectory, _standardAnalyzer, IndexWriter.MaxFieldLength.UNLIMITED);
}
public void HelloWorldTest()
{
Directory directory = new RAMDirectory();
Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_29);
IndexWriter writer = new IndexWriter(directory,
analyzer,
IndexWriter.MaxFieldLength.UNLIMITED);
Document doc = new Document();
doc.Add(new Field("id", "1", Field.Store.YES, Field.Index.NO));
doc.Add(new Field("postBody", "sample test", Field.Store.YES, Field.Index.ANALYZED));
writer.AddDocument(doc);
writer.Optimize();
writer.Commit();
writer.Close();
QueryParser parser = new QueryParser(Version.LUCENE_29, "postBody", analyzer);
Query query = parser.Parse("sample test");
//Setup searcher
IndexSearcher searcher = new IndexSearcher(directory, true);
//Do the search
var hits = searcher.Search(query, null, 10);
for (int i = 0; i < hits.TotalHits; i++)
{
var doc1 = hits.ScoreDocs[i];
}
searcher.Close();
directory.Close();
}
public void Dispose()
{
if (!_disposed)
{
if (_index != null)
{
_index.Dispose();
_index = null;
}
if (_analyzer != null)
{
_analyzer.Dispose();
_analyzer = null;
}
if (_directory != null)
{
_directory.Dispose();
_directory = null;
}
_disposed = true;
}
}
public IEnumerable<Hit> Search(string query, int maxResults)
{
var analyzer = new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_29);
QueryParser qp = new QueryParser(
Lucene.Net.Util.Version.LUCENE_29,
"contents",
analyzer
);
Query q = qp.Parse(query);
TopDocs top = searcher.Search(q, maxResults);
List<Hit> result = new List<Hit>(top.totalHits);
for (int index = 0; index < top.totalHits; index++)
{
var doc = searcher.Doc(top.scoreDocs[index].doc);
string contents = doc.Get("contents");
var scorer = new QueryScorer(q, searcher.GetIndexReader(), "contents");
var highlighter = new Highlighter(scorer);
result.Add(new Hit()
{
Relevance = top.scoreDocs[index].score,
Title = doc.Get("title"),
Url = doc.Get("path"),
Excerpt = highlighter.GetBestFragment(analyzer, "contents", contents)
});
}
return result;
}
private static Query ParseQuery(string searchTerm)
{
var fields = new Dictionary<string, float> { { "Id", 1.2f }, { "Title", 1.0f }, { "Tags", 1.0f}, { "Description", 0.8f }, { "Author", 0.6f } };
var analyzer = new StandardAnalyzer(LuceneCommon.LuceneVersion);
searchTerm = QueryParser.Escape(searchTerm).ToLowerInvariant();
var queryParser = new MultiFieldQueryParser(LuceneCommon.LuceneVersion, fields.Keys.ToArray(), analyzer, fields);
var conjuctionQuery = new BooleanQuery();
conjuctionQuery.SetBoost(1.5f);
var disjunctionQuery = new BooleanQuery();
var wildCardQuery = new BooleanQuery();
wildCardQuery.SetBoost(0.7f);
var exactIdQuery = new TermQuery(new Term("Id-Exact", searchTerm));
exactIdQuery.SetBoost(2.5f);
foreach(var term in searchTerm.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries))
{
conjuctionQuery.Add(queryParser.Parse(term), BooleanClause.Occur.MUST);
disjunctionQuery.Add(queryParser.Parse(term), BooleanClause.Occur.SHOULD);
foreach (var field in fields)
{
var wildCardTermQuery = new WildcardQuery(new Term(field.Key, term + "*"));
wildCardTermQuery.SetBoost(0.7f * field.Value);
wildCardQuery.Add(wildCardTermQuery, BooleanClause.Occur.SHOULD);
}
}
return conjuctionQuery.Combine(new Query[] { exactIdQuery, conjuctionQuery, disjunctionQuery, wildCardQuery });
}
/// <summary>
/// Performs the explanation.
/// </summary>
/// <param name="luceneVersion">The lucene version.</param>
/// <param name="fsDirectory">The fs directory.</param>
/// <param name="searchQuery">The search query.</param>
/// <param name="resultId">The result identifier.</param>
/// <returns></returns>
protected virtual string PerformExplain(Version luceneVersion, FSDirectory fsDirectory, string searchQuery, int resultId)
{
/*
* The obvious problem here is that we're not using the exact same search as the real one.
*/
var explanation = string.Empty;
using (var indexSearcher = new IndexSearcher(fsDirectory, false))
{
var analyzer = new StandardAnalyzer(luceneVersion);
var queryParser = new MultiFieldQueryParser(luceneVersion, new[] { "Id".ToLowerInvariant() }, analyzer)
{
DefaultOperator = QueryParser.Operator.AND
};
var query = this.searchQueryParser.ParseQuery(searchQuery, queryParser);
explanation = indexSearcher.Explain(query, resultId).ToHtml();
analyzer.Close();
}
return explanation;
}
public static void CreateIndex() {
try
{
var cloudAccount = Azure.GetStorageAccount();
using (var cacheDirectory = new RAMDirectory())
{
using (var azureDirectory = new AzureDirectory(cloudAccount, Azure.StorageContainerName, cacheDirectory))
{
using (Analyzer analyzer = new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30))
{
using (var indexWriter = new IndexWriter(azureDirectory, analyzer, true, IndexWriter.MaxFieldLength.UNLIMITED))
{
AddDocuments(indexWriter);
indexWriter.Commit();
}
}
}
}
}
catch (StorageException ex)
{
Trace.TraceError(ex.Message);
}
}
public Engine()
{
var directory = new RAMDirectory();
var analyzer = new StandardAnalyzer(Version.LUCENE_30);
using (var indexWriter = new IndexWriter(directory, analyzer, true, IndexWriter.MaxFieldLength.LIMITED))
{
for (int i = 0; i < 10000; i++)
{
Console.Write(".");
var document = new Document();
document.Add(new Field("Id", i.ToString(), Field.Store.YES, Field.Index.NOT_ANALYZED));
document.Add(new Field("Name", "Name" + i.ToString(), Field.Store.YES, Field.Index.ANALYZED));
indexWriter.AddDocument(document);
}
}
Console.ReadKey();
var queryParser = new QueryParser(Version.LUCENE_30, "Name", analyzer);
var query = queryParser.Parse("Name37~");
IndexReader indexReader = IndexReader.Open(directory, true);
var searcher = new IndexSearcher(indexReader);
TopDocs resultDocs = searcher.Search(query, indexReader.MaxDoc);
}
public void CreateIndex(List<ISearchEntity> CreateEntities)
{
Analyzer analyzer = new StandardAnalyzer();
IndexWriter writer = new IndexWriter(ConfigElement.IndexDirectory, analyzer, true);
//第三个参数：是否重新创建索引，True 一律清空 重新建立 False 原有基础上增量添加索引
foreach (ISearchEntity IndexEntity in CreateEntities)
{
ProductModel product = (ProductModel)IndexEntity;
Document doc = new Document();
doc.Add(new Field("productid", Convert.ToString(product.EntityIdentity), Field.Store.YES, Field.Index.UN_TOKENIZED));
doc.Add(new Field("productname", Convert.ToString(product.ProductName), Field.Store.YES, Field.Index.TOKENIZED));
doc.Add(new Field("cateid", Convert.ToString(product.CategoryID), Field.Store.YES, Field.Index.UN_TOKENIZED));
doc.Add(new Field("catepath", Convert.ToString(product.CategoryPath), Field.Store.YES, Field.Index.UN_TOKENIZED));
doc.Add(new Field("keywords", Convert.ToString(product.Keywords), Field.Store.YES, Field.Index.TOKENIZED));
doc.Add(new Field("description", Convert.ToString(product.Description), Field.Store.YES, Field.Index.TOKENIZED));
doc.Add(new Field("price", Convert.ToString(product.Price), Field.Store.YES, Field.Index.UN_TOKENIZED));
doc.Add(new Field("createtime", Convert.ToString(product.CreateTime), Field.Store.YES, Field.Index.UN_TOKENIZED));
doc.Add(new Field("updatetime", Convert.ToString(product.UpdateTime), Field.Store.YES, Field.Index.UN_TOKENIZED));
doc.Add(new Field("mainimage", Convert.ToString(product.ProductImage), Field.Store.YES, Field.Index.UN_TOKENIZED));
writer.AddDocument(doc);
Console.WriteLine("created index for {0}:{1}", product.EntityIdentity, product.ProductName);
}
writer.Optimize();
writer.Close();
}
public static UmbracoContentIndexer GetUmbracoIndexer(
Lucene.Net.Store.Directory luceneDir,
Analyzer analyzer = null,
IDataService dataService = null)
{
if (dataService == null)
{
dataService = new TestDataService();
}
if (analyzer == null)
{
analyzer = new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_29);
}
var indexSet = new IndexSet();
var indexCriteria = indexSet.ToIndexCriteria(dataService, UmbracoContentIndexer.IndexFieldPolicies);
var i = new UmbracoContentIndexer(indexCriteria,
luceneDir, //custom lucene directory
dataService,
analyzer,
false);
//i.IndexSecondsInterval = 1;
i.IndexingError += IndexingError;
return i;
}
static void Main(string[] args)
{
// Path to index file.
Directory pdfIndex = FSDirectory.Open(@"/* PASTE THE PATH WHERE YOUR INDEX WILL BE SAVED */");
// Creating analyzer to make index searchable.
Analyzer analyzer = new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30);
// Creating IndexWriter
IndexWriter.MaxFieldLength mfl = new IndexWriter.MaxFieldLength(100000);
IndexWriter writer = new IndexWriter(pdfIndex, analyzer, mfl);
// Full path to input .pdf files.
string[] filesList = System.IO.Directory.GetFiles(@"/* PASTE THE PATH TO YOUR INPUT FILE(S) */", "*.pdf");
/* INDEX FIELDS:
** id & body are the fields to my Lucene Index,
** you can change those fields accordingly to your
** needs
*/
int idNumber = 0;
string pdfText;
foreach (string file in filesList)
{
pdfText = GetAllText(file);
AddToIndex(idNumber, pdfText, writer);
idNumber++;
}
writer.Dispose();
DisplayAllInput(filesList);
Console.ReadKey();
}
public void GetAllMoviesWith(string textSearch, int maxCount, out List<string> movies, out List<string> reviews, IList<string> filters = null)
{
reviews = new List<string>();
movies = new List<string>();
try
{
var analyzer = new StandardAnalyzer(Version.LUCENE_30);
var query = ParseQuery(textSearch, filters, analyzer);
var hits = _searcher.Search(query, 10);
if (hits == null)
{
Trace.TraceWarning("Search query {0} didn't generate any results", textSearch);
return;
}
else
{
Trace.TraceInformation("Results for search query {0} : hits {1} max score {2} score docs {3}", textSearch, hits.TotalHits, hits.MaxScore, hits.ScoreDocs);
foreach (var doc in hits.ScoreDocs)
{
GetIdsFromSearchQueries(_searcher.Doc(doc.Doc), movies, reviews);
}
}
}
catch (Exception err)
{
Trace.TraceError("Get all movies failed with exception {0}", err);
throw;
}
}
public static Query BuildQuery(string query)
{
var untokenizedMatches = untokenizedQuery.Matches(query);
var rangeMatches = rangeQuery.Matches(query);
var standardAnalyzer = new StandardAnalyzer(Version.LUCENE_29);
try
{
if (untokenizedMatches.Count == 0 && rangeMatches.Count == 0)
return new QueryParser(Version.LUCENE_29, "", standardAnalyzer).Parse(query);
var sb = new StringBuilder(query);
var booleanQuery = new BooleanQuery();
AddUntokenizedTerms(untokenizedMatches, booleanQuery, sb, query);
AddRangeTerms(rangeMatches, booleanQuery, sb, query);
var remaining = sb.ToString();
remaining = hangingConditionAtStart.Replace(remaining, "");
remaining = hangingConditionAtEnd.Replace(remaining, "");
remaining = remaining.Trim();
if (remaining.Length > 0)
{
booleanQuery.Add(new QueryParser(Version.LUCENE_29, "", standardAnalyzer).Parse(remaining), BooleanClause.Occur.SHOULD);
}
return booleanQuery;
}
finally
{
standardAnalyzer.Close();
}
}
public Data searchLucene(Data data)
{
Account_lg account = new Account_lg();
List<string> item = new List<string>();
Lucene.Net.Store.Directory directory = FSDirectory.Open(new DirectoryInfo("C:\\Visual Studio 2010\\Transaction" + "\\LuceneIndex"));
var analyzer = new StandardAnalyzer(Version.LUCENE_29);
IndexReader reader = IndexReader.Open(directory, true);
IndexSearcher searcher = new IndexSearcher(reader);
MultiFieldQueryParser parser = new MultiFieldQueryParser(Lucene.Net.Util.Version.LUCENE_29, new string[] { "name", "username" }, analyzer); //search for multifield
Query query = parser.Parse((data.getString("search")) + "*"); //cant search blank text with wildcard as first character
TopScoreDocCollector collector = TopScoreDocCollector.Create(1000, true);
searcher.Search(query, collector);
ScoreDoc[] hits = collector.TopDocs().ScoreDocs;
int count = hits.Length;
for (int i = 0; i < count; i++)
{
int docId = hits[i].Doc;
float score = hits[i].Score;
Document doc = searcher.Doc(docId);
string id = doc.Get("id");
item.Add(id);
}
Data list = account.selectUser(data, item.ToArray());
reader.Dispose();
searcher.Dispose();
return list;
}
public void TestMethod1()
{
Lucene.Net.Analysis.Standard.StandardAnalyzer a = new Lucene.Net.Analysis.Standard.StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30);
string s = "我日中华人民共和国";
System.IO.StringReader reader = new System.IO.StringReader(s);
Lucene.Net.Analysis.TokenStream ts = a.TokenStream(s, reader);
bool hasnext = ts.IncrementToken();
Lucene.Net.Analysis.Tokenattributes.ITermAttribute ita;
while (hasnext)
{
ita = ts.GetAttribute <Lucene.Net.Analysis.Tokenattributes.ITermAttribute>();
Console.WriteLine(ita.Term);
hasnext = ts.IncrementToken();
}
Console.WriteLine("over");
ts.CloneAttributes();
reader.Close();
a.Close();
}
/// <summary>
/// Inits this instance.
/// </summary>
public void Init()
{
server = new HttpServer();
Url = server.Url;
var indexDir = Content.Index;
indexReader = IndexReader.Open(indexDir, true);
indexSearcher = new IndexSearcher(indexReader);
analyzer = new StandardAnalyzer(Version.LUCENE_29);
server.ProcessRequest += ServerProcessRequest;
server.Start();
var labels = new StringBuilder();
// Sort tags by alphabetical order
Content.Tags.Sort((from, to) => from.Name.CompareTo(to.Name));
foreach (var tagIndex in Content.Tags)
{
labels.AppendFormat(
@"<label style='float: left; margin-right: 8px'><input type='checkbox' name='{0}' checked='true'/>{1}</label>",
tagIndex.Id, tagIndex.Name).AppendLine();
}
searchOptions = labels.ToString();
}
private void button2_Click(object sender, EventArgs e)
{
String field = "content";
IndexReader reader = IndexReader.Open(FSDirectory.Open(new DirectoryInfo(INDEX_DIR.FullName)), true);
Searcher searcher = new IndexSearcher(reader);
Analyzer analyzer = new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30);
QueryParser parser = new QueryParser(Lucene.Net.Util.Version.LUCENE_30, field, analyzer);
Query query = parser.Parse(textBox1.Text.Trim());
TopScoreDocCollector collector = TopScoreDocCollector.Create(searcher.MaxDoc, false);
searcher.Search(query, collector);
ScoreDoc[] hits = collector.TopDocs().ScoreDocs;
MessageBox.Show(this, "共 " + collector.TotalHits.ToString() + " 条记录");
//ltrResult.Text = "共 " + collector.GetTotalHits().ToString() + " 条记录<br>";
//for (Int32 i = 0; i < collector.GetTotalHits(); i++)
//{
// ltrResult.Text += "doc=" + hits[i].doc + " score=" + hits[i].score + "<br>";
// Document doc = searcher.Doc(hits[i].doc);
// ltrResult.Text += "Path:" + doc.Get("path") + "<br>";
//}
reader.Dispose();
}
public Data searchLucene(Data data)
{
Search_gl search = new Search_gl();
List<string> item = new List<string>();
Lucene.Net.Store.Directory directory = FSDirectory.Open(new DirectoryInfo(Environment.CurrentDirectory + "\\LuceneIndex"));
var analyzer = new StandardAnalyzer(Version.LUCENE_29);
IndexReader reader = IndexReader.Open(directory, true);
IndexSearcher searcher = new IndexSearcher(reader);
//QueryParser queryParser = new QueryParser(Version.LUCENE_29, "summary", analyzer); //search for single field
MultiFieldQueryParser parser = new MultiFieldQueryParser(new string[] {"name", "summary"}, analyzer); //search for multifield
Query query = parser.Parse((data.getString("search")) + "*"); //cant search blank text with wildcard as first character
TopScoreDocCollector collector = TopScoreDocCollector.create(1000, true);
searcher.Search(query, collector);
ScoreDoc[] hits = collector.TopDocs().ScoreDocs;
int count = hits.Length;
for (int i = 0; i < count; i++)
{
int docId = hits[i].doc;
float score = hits[i].score;
Document doc = searcher.Doc(docId);
string id = doc.Get("id");
item.Add(id);
}
Data list = search.search(data, item.ToArray());
reader.Close();
searcher.Close();
return list;
}
public TheIndexService()
{
_version = Version.LUCENE_30;
_analyzer = new StandardAnalyzer(_version);
_path =
new DirectoryInfo(AppDomain.CurrentDomain.BaseDirectory + ConfigurationManager.AppSettings["pathIndex"]);
}
public ISearchResult Search(string query)
{
var timer = new Stopwatch();
timer.Start();
var directory = FSDirectory.Open(new DirectoryInfo(path));
var analyzer = new StandardAnalyzer(Version.LUCENE_29);
var searcher = new IndexSearcher(directory, true);
var queryParser = new QueryParser(Version.LUCENE_29, "text", analyzer);
var result = searcher.Search(queryParser.Parse(query), 20);
var docs = (from scoreDoc in result.scoreDocs
let doc = searcher.Doc(scoreDoc.doc)
let fields = new Dictionary<string, string> { { "title", doc.Get("title") }, { "text", doc.Get("text") } }
select new LuceneDocument { Id = scoreDoc.doc.ToString(), Fields = fields }).ToList();
var ret = new SearchResult { Query = query, Total = result.totalHits, Documents = docs, Source = Name };
searcher.Close();
directory.Close();
timer.Stop();
ret.Duration = (decimal) timer.Elapsed.TotalSeconds;
return ret;
}
public void v()
{
//Analyzer analyzer = new CJKAnalyzer();
//TokenStream tokenStream = analyzer.TokenStream("", new StringReader("我爱你中国China中华人名共和国"));
//Lucene.Net.Analysis.Token token = null;
//while ((token = tokenStream.Next()) != null)
//{
// Response.Write(token.TermText() + "<br/>");
//}
Lucene.Net.Analysis.Standard.StandardAnalyzer a = new Lucene.Net.Analysis.Standard.StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30);
string s = "我日中华人民共和国";
System.IO.StringReader reader = new System.IO.StringReader(s);
Lucene.Net.Analysis.TokenStream ts = a.TokenStream(s, reader);
bool hasnext = ts.IncrementToken();
Lucene.Net.Analysis.Tokenattributes.ITermAttribute ita;
while (hasnext)
{
ita = ts.GetAttribute <Lucene.Net.Analysis.Tokenattributes.ITermAttribute>();
Console.WriteLine(ita.Term);
hasnext = ts.IncrementToken();
}
ts.CloneAttributes();
reader.Close();
a.Close();
Console.ReadKey();
}
public void MyTestMethod1()
{
//IndexWriter writer = new IndexWriter(@"c:/index/", new ChineseAnalyzer(), true);
Lucene.Net.Analysis.Standard.StandardAnalyzer a = new Lucene.Net.Analysis.Standard.StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30);
Lucene.Net.Store.Directory dir = Lucene.Net.Store.FSDirectory.Open("d:/index/");
IndexWriter writer = new IndexWriter(dir, a, true, new IndexWriter.MaxFieldLength(100));
Document doc = new Document();
}
private void FixtureSetup()
{
directory = new RAMDirectory();
standardAnalyzer = new Lucene.Net.Analysis.Standard.StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30);
writer = new IndexWriter(directory, standardAnalyzer, IndexWriter.MaxFieldLength.UNLIMITED);
Document doc = new Document();
doc.Add(new Field("content", "The quick brown fox jumps over the lazy dogs", Field.Store.NO, Field.Index.ANALYZED));
writer.AddDocument(doc);
writer.Dispose();
searcher = new IndexSearcher(directory);
}
public void FixtureSetup()
{
directory = new RAMDirectory();
standardAnalyzer = new Lucene.Net.Analysis.Standard.StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30);
writer = new IndexWriter(directory, standardAnalyzer, IndexWriter.MaxFieldLength.UNLIMITED);
AddDocuments(new List <string>()
{
"[Rosa]", "Rosa", "Olá"
});
writer.Dispose();
searcher = new IndexSearcher(directory);
}
public List <RetreivedQuiz> GetQuizzes(string q)
{
List <RetreivedQuiz> ret = new List <RetreivedQuiz>();
using (Analyzer analyzerStandard = new Lucene.Net.Analysis.Standard.StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_29))
{
QueryParser parser = new QueryParser(Lucene.Net.Util.Version.LUCENE_CURRENT, "", analyzerStandard);
using (IndexSearcher indexSearcher = new IndexSearcher(directory, true))
{
var query = parser.Parse("Title:" + q + "*");
TopDocs result = indexSearcher.Search(query, 20);
Console.WriteLine("N° results in index:" + result.TotalHits);
for (int i = 0; i < result.ScoreDocs.Length; i++)
{
var score = result.ScoreDocs[i].Score;
Document doc = indexSearcher.Doc(result.ScoreDocs[i].Doc);
var Id = doc.Get("Id");
Console.WriteLine("Match id " + Id + " score " + score);
ret.Add(new RetreivedQuiz(Convert.ToInt32(doc.Get("Quiz_id")), doc.Get("Title"), doc.Get("Subject"), Convert.ToInt32(doc.Get("Questions"))));
}
}
}
return(ret);
}
public TokenStreamComponentsAnonymousInnerClassHelper(StandardAnalyzer outerInstance, StandardTokenizer src, TokenStream tok, Reader reader) : base(src, tok)
{
this.outerInstance = outerInstance;
this.reader = reader;
this.src = src;
}
public SqloogleMiaSearcher(string indexPath, int resultsLimit = 50)
{
_resultsLimit = resultsLimit;
var fields = new[] {
"server",
"database",
"schema",
"name",
"equality",
"inequality",
"included"
};
var boosts = new Dictionary<string, float> {
{ "server", .4F },
{ "database", .3F },
{ "schema", .2F },
{ "name", .1F },
{ "equality", .0F },
{ "inequality", .0F },
{ "included", .0F }
};
_directory = FSDirectory.Open(new DirectoryInfo(indexPath));
_searcher = new IndexSearcher(_directory, true);
_analyzer = new StandardAnalyzer(Version.LUCENE_30);
_parser = new MultiFieldQueryParser(Version.LUCENE_30, fields, _analyzer, boosts) {
DefaultOperator = QueryParser.Operator.AND
};
_logger.Trace("Searcher is ready.");
}
