Repository navigation
Expand file tree
/
Copy pathLuceneIndex.cs
More file actions
349 lines (279 loc) · 13.4 KB
/
Copy pathLuceneIndex.cs
File metadata and controls
349 lines (279 loc) · 13.4 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
using System;
using System.Threading.Tasks;
using MongoLucene;
class Program
{
static async Task Main(string[] args)
{
// Initialize the MongoDB Lucene index
var connectionString = "mongodb://localhost:27017";
var databaseName = "SearchDatabase";
var indexName = "DocumentIndex";
var mongoIndex = new MongoLuceneIndex(connectionString, databaseName, indexName);
// Example 1: Indexing documents
await IndexDocuments(mongoIndex);
// Example 2: Simple searching
await SimpleSearch(mongoIndex);
// Example 3: Advanced querying
await AdvancedSearch(mongoIndex);
// Example 4: Boolean queries
await BooleanSearch(mongoIndex);
// Example 5: Phrase queries
await PhraseSearch(mongoIndex);
Console.WriteLine("\nAll examples completed successfully!");
}
static async Task IndexDocuments(MongoLuceneIndex mongoIndex)
{
Console.WriteLine("=== Indexing Documents ===");
var writer = mongoIndex.GetWriter(new StandardAnalyzer());
// Index some sample documents
await writer.AddDocumentAsync("doc1",
new Field("title", "Introduction to MongoDB", FieldType.Text, stored: true, indexed: true),
new Field("content", "MongoDB is a document-oriented NoSQL database system. It stores data in flexible, JSON-like documents.", FieldType.Text, stored: true, indexed: true),
new Field("author", "John Doe", FieldType.Keyword, stored: true, indexed: true, analyzed: false),
new Field("category", "Database", FieldType.Keyword, stored: true, indexed: true, analyzed: false),
new Field("published_date", DateTime.Parse("2023-01-15"), FieldType.Date, stored: true, indexed: true)
);
await writer.AddDocumentAsync("doc2",
new Field("title", "Lucene.NET Search Engine", FieldType.Text, stored: true, indexed: true),
new Field("content", "Lucene.NET is a port of the popular Apache Lucene search library to .NET. It provides full-text search capabilities.", FieldType.Text, stored: true, indexed: true),
new Field("author", "Jane Smith", FieldType.Keyword, stored: true, indexed: true, analyzed: false),
new Field("category", "Search", FieldType.Keyword, stored: true, indexed: true, analyzed: false),
new Field("published_date", DateTime.Parse("2023-02-20"), FieldType.Date, stored: true, indexed: true)
);
await writer.AddDocumentAsync("doc3",
new Field("title", "C# Programming Best Practices", FieldType.Text, stored: true, indexed: true),
new Field("content", "This article covers best practices for C# development including SOLID principles, design patterns, and performance optimization.", FieldType.Text, stored: true, indexed: true),
new Field("author", "Mike Johnson", FieldType.Keyword, stored: true, indexed: true, analyzed: false),
new Field("category", "Programming", FieldType.Keyword, stored: true, indexed: true, analyzed: false),
new Field("published_date", DateTime.Parse("2023-03-10"), FieldType.Date, stored: true, indexed: true)
);
await writer.AddDocumentAsync("doc4",
new Field("title", "Database Design Patterns", FieldType.Text, stored: true, indexed: true),
new Field("content", "Exploring various database design patterns for both SQL and NoSQL databases. Learn about normalization, denormalization, and schema design.", FieldType.Text, stored: true, indexed: true),
new Field("author", "Sarah Wilson", FieldType.Keyword, stored: true, indexed: true, analyzed: false),
new Field("category", "Database", FieldType.Keyword, stored: true, indexed: true, analyzed: false),
new Field("published_date", DateTime.Parse("2023-04-05"), FieldType.Date, stored: true, indexed: true)
);
await writer.CommitAsync();
Console.WriteLine("Indexed 4 documents successfully.");
}
static async Task SimpleSearch(MongoLuceneIndex mongoIndex)
{
Console.WriteLine("\n=== Simple Search ===");
var searcher = mongoIndex.GetSearcher();
var parser = mongoIndex.GetQueryParser("content");
// Simple term search
var query = parser.Parse("MongoDB");
var results = await searcher.SearchAsync(query, maxResults: 10);
Console.WriteLine($"Found {results.TotalHits} documents for 'MongoDB' (took {results.QueryTime.TotalMilliseconds}ms):");
foreach (var result in results.Results)
{
Console.WriteLine($"- {result.Fields["title"]} (Score: {result.Score:F2})");
Console.WriteLine($" Author: {result.Fields["author"]}");
Console.WriteLine($" Category: {result.Fields["category"]}");
Console.WriteLine();
}
}
static async Task AdvancedSearch(MongoLuceneIndex mongoIndex)
{
Console.WriteLine("=== Advanced Search ===");
var searcher = mongoIndex.GetSearcher();
// Create a more complex query using TermQuery directly
var query = new TermQuery("category", "Database");
var results = await searcher.SearchAsync(query, maxResults: 10);
Console.WriteLine($"Found {results.TotalHits} documents in 'Database' category:");
foreach (var result in results.Results)
{
Console.WriteLine($"- {result.Fields["title"]}");
Console.WriteLine($" Content: {result.Fields["content"].ToString().Substring(0, Math.Min(100, result.Fields["content"].ToString().Length))}...");
Console.WriteLine();
}
}
static async Task BooleanSearch(MongoLuceneIndex mongoIndex)
{
Console.WriteLine("=== Boolean Search ===");
var searcher = mongoIndex.GetSearcher();
// Create a boolean query: documents that contain "database" AND are in "Database" category
var boolQuery = new BooleanQuery();
boolQuery.Add(new TermQuery("content", "database"), BooleanClause.Occur.Must);
boolQuery.Add(new TermQuery("category", "Database"), BooleanClause.Occur.Must);
var results = await searcher.SearchAsync(boolQuery, maxResults: 10);
Console.WriteLine($"Found {results.TotalHits} documents with 'database' content in 'Database' category:");
foreach (var result in results.Results)
{
Console.WriteLine($"- {result.Fields["title"]}");
Console.WriteLine($" Author: {result.Fields["author"]}");
Console.WriteLine();
}
// Boolean query with OR condition
Console.WriteLine("\nOR Query - documents about 'MongoDB' OR 'Lucene':");
var orQuery = new BooleanQuery();
orQuery.Add(new TermQuery("content", "mongodb"), BooleanClause.Occur.Should);
orQuery.Add(new TermQuery("content", "lucene"), BooleanClause.Occur.Should);
var orResults = await searcher.SearchAsync(orQuery, maxResults: 10);
Console.WriteLine($"Found {orResults.TotalHits} documents:");
foreach (var result in orResults.Results)
{
Console.WriteLine($"- {result.Fields["title"]}");
}
Console.WriteLine();
}
static async Task PhraseSearch(MongoLuceneIndex mongoIndex)
{
Console.WriteLine("=== Phrase Search ===");
var searcher = mongoIndex.GetSearcher();
// Search for exact phrase
var phraseQuery = new PhraseQuery("content", "design", "patterns");
var results = await searcher.SearchAsync(phraseQuery, maxResults: 10);
Console.WriteLine($"Found {results.TotalHits} documents containing phrase 'design patterns':");
foreach (var result in results.Results)
{
Console.WriteLine($"- {result.Fields["title"]}");
Console.WriteLine($" Category: {result.Fields["category"]}");
Console.WriteLine();
}
}
}
// Additional helper classes for more advanced functionality
namespace MongoLucene.Extensions
{
public static class QueryExtensions
{
public static Query CreateWildcardQuery(string field, string pattern)
{
// Convert wildcard pattern to regex
var regexPattern = pattern.Replace("*", ".*").Replace("?", ".");
return new RegexQuery(field, regexPattern);
}
public static Query CreateRangeQuery(string field, object lowerValue, object upperValue, bool includeLower = true, bool includeUpper = true)
{
return new RangeQuery(field, lowerValue, upperValue, includeLower, includeUpper);
}
}
// Additional query types
public class RegexQuery : Query
{
public string Field { get; set; }
public string Pattern { get; set; }
public RegexQuery(string field, string pattern)
{
Field = field;
Pattern = pattern;
}
public override FilterDefinition<IndexedDocument> ToMongoFilter()
{
return Builders<IndexedDocument>.Filter.Regex($"Fields.{Field}",
new MongoDB.Bson.BsonRegularExpression(Pattern, "i"));
}
}
public class RangeQuery : Query
{
public string Field { get; set; }
public object LowerValue { get; set; }
public object UpperValue { get; set; }
public bool IncludeLower { get; set; }
public bool IncludeUpper { get; set; }
public RangeQuery(string field, object lowerValue, object upperValue, bool includeLower = true, bool includeUpper = true)
{
Field = field;
LowerValue = lowerValue;
UpperValue = upperValue;
IncludeLower = includeLower;
IncludeUpper = includeUpper;
}
public override FilterDefinition<IndexedDocument> ToMongoFilter()
{
var builder = Builders<IndexedDocument>.Filter;
var fieldPath = $"Fields.{Field}";
var filters = new List<FilterDefinition<IndexedDocument>>();
if (LowerValue != null)
{
if (IncludeLower)
filters.Add(builder.Gte(fieldPath, LowerValue));
else
filters.Add(builder.Gt(fieldPath, LowerValue));
}
if (UpperValue != null)
{
if (IncludeUpper)
filters.Add(builder.Lte(fieldPath, UpperValue));
else
filters.Add(builder.Lt(fieldPath, UpperValue));
}
return filters.Count > 1 ? builder.And(filters) : filters.FirstOrDefault() ?? builder.Empty;
}
}
// Sorting support
public class SortField
{
public string Field { get; set; }
public SortOrder Order { get; set; }
public SortField(string field, SortOrder order = SortOrder.Ascending)
{
Field = field;
Order = order;
}
}
public enum SortOrder
{
Ascending,
Descending
}
// Enhanced searcher with sorting
public class EnhancedIndexSearcher : IndexSearcher
{
private readonly IMongoCollection<IndexedDocument> _collection;
public EnhancedIndexSearcher(IMongoDatabase database, string indexName) : base(database, indexName)
{
_collection = database.GetCollection<IndexedDocument>(indexName);
}
public async Task<SearchResults> SearchAsync(Query query, int maxResults = 10, int skip = 0, params SortField[] sortFields)
{
var startTime = DateTime.UtcNow;
var filter = query.ToMongoFilter();
var totalCount = await _collection.CountDocumentsAsync(filter);
var findFluent = _collection.Find(filter);
// Apply sorting
if (sortFields?.Length > 0)
{
var sortDefinition = CreateSortDefinition(sortFields);
findFluent = findFluent.Sort(sortDefinition);
}
var documents = await findFluent
.Skip(skip)
.Limit(maxResults)
.ToListAsync();
var results = documents.Select(doc => new SearchResult
{
Document = doc,
Score = CalculateScore(doc, query),
Fields = doc.Fields
}).ToList();
// If no explicit sorting, sort by score
if (sortFields?.Length == 0)
{
results = results.OrderByDescending(r => r.Score).ToList();
}
return new SearchResults
{
Results = results,
TotalHits = totalCount,
QueryTime = DateTime.UtcNow - startTime
};
}
private SortDefinition<IndexedDocument> CreateSortDefinition(SortField[] sortFields)
{
var sortBuilder = Builders<IndexedDocument>.Sort;
SortDefinition<IndexedDocument> sortDefinition = null;
foreach (var sortField in sortFields)
{
var fieldSort = sortField.Order == SortOrder.Ascending
? sortBuilder.Ascending($"Fields.{sortField.Field}")
: sortBuilder.Descending($"Fields.{sortField.Field}");
sortDefinition = sortDefinition == null ? fieldSort : sortDefinition.ThenBy(fieldSort);
}
return sortDefinition;
}
}
}