internal static bool TryParse(string uriString, out LuceneQuery viewQuery)
{
Uri uri;
viewQuery = null;
return(Uri.TryCreate(uriString, UriKind.Relative, out uri) && TryParse(uri, out viewQuery));
}
public async Task <IActionResult> Content(
string indexName,
string query,
string parameters)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.QueryLuceneApi))
{
return(Unauthorized());
}
var luceneQuery = new LuceneQuery
{
Index = indexName,
Template = query,
ReturnContentItems = true
};
var queryParameters = parameters != null?
JsonConvert.DeserializeObject <Dictionary <string, object> >(parameters)
: new Dictionary <string, object>();
var result = await _luceneQuerySource.ExecuteQueryAsync(luceneQuery, queryParameters);
return(new ObjectResult(result));
}
internal static bool TryParse(Uri uri, out LuceneQuery viewQuery)
{
if (uri.IsAbsoluteUri)
{
viewQuery = null;
return(false);
}
var match = Regex.Match(
uri.ToString(), "^_design/(?<designDocName>.*?)/(?<indexName>.*?)(?:\\?(?<queryString>.*))?$");
if (match.Success)
{
viewQuery = new LuceneQuery {
DesignDocumentName = match.Groups["designDocName"].Value,
IndexName = match.Groups["indexName"].Value
};
var queryStringGroup = match.Groups["queryString"];
if (queryStringGroup.Success)
{
OptionListSerializer.Parse(queryStringGroup.Value, ref viewQuery);
}
return(true);
}
viewQuery = null;
return(false);
}
internal static string ToUriString(LuceneQuery viewQuery, ISerializer serializer = null)
{
if (viewQuery.DesignDocumentName.HasNoValue() || viewQuery.IndexName.HasNoValue())
{
return(null);
}
if (serializer == null)
{
serializer = new NewtonsoftSerializer();
}
var uri = new StringBuilder();
uri.Append("_design/")
.Append(viewQuery.DesignDocumentName)
.Append("/")
.Append(viewQuery.IndexName);
var queryString = OptionListSerializer.ToQueryString(viewQuery, serializer);
if (queryString.Length > 0)
{
uri.Append("?").Append(queryString);
}
return(uri.ToString());
}
public Uri GetQueryUri(LuceneQuery query)
{
var sectionFtiBaseUri = new Uri(databaseFtiEndpoint, query.SectionName + "/");
var databaseFtiBaseUri = new Uri(sectionFtiBaseUri, databaseNameWithSlash);
return(new Uri(databaseFtiBaseUri, query.ToUri()));
}
/// <constructor />
public LuceneQueryResult(
LuceneQuery query, IEnumerable <LuceneResultRow> rows,
int count, int?totalCount, int?offset, TimeSpan fetchDuration, TimeSpan searchDuration, int limit, int skip)
: base(rows, count, totalCount, offset)
{
Init(query, fetchDuration, searchDuration, limit, skip);
}
public void LuceneController_Search_Double_FuzzyQuery()
{
// Arrange
string[] docs =
{
"home",
"homez", // note home and homes could be returned by PorterFilter
"fuzzy",
"wuzzy",
};
string[] keywords =
{
"wuzza",
"homy",
};
this.AddLinesAsSearchDocs(docs);
// Act
var finalQuery = new BooleanQuery();
foreach (var keyword in keywords)
{
finalQuery.Add(new FuzzyQuery(new Term(Constants.ContentTag, keyword)), Occur.SHOULD);
}
var luceneQuery = new LuceneQuery {
Query = finalQuery
};
var previews = this.luceneController.Search(this.CreateSearchContext(luceneQuery));
// Assert
Assert.AreEqual(3, previews.Results.Count());
}
/// <summary>Loads view request result from provided <see cref="TextReader"/>.</summary>
public static ILuceneQueryResult Parse(TextReader textReader, LuceneQuery query)
{
var response = ParseRawResponse(textReader);
var totalRows = GetTotalRows(response);
var offset = GetOffset(response);
var rawRows = GetRawRows(response);
var fetchDuration = TimeSpan.FromMilliseconds(response.GetPrimitiveProperty<int>("fetch_duration"));
var searchDuration = TimeSpan.FromMilliseconds(response.GetPrimitiveProperty<int>("search_duration"));
var limit = response.GetPrimitiveProperty<int>("limit");
var skip = response.GetPrimitiveProperty<int>("skip");
var rows = (
from rawRow in rawRows
let id = rawRow.GetPrimitiveProperty<string>("id")
let fields = rawRow.TryGetValue("fields")
let score = rawRow.GetPrimitiveProperty<decimal>("score")
let documentJsonObject = rawRow.TryGetValue("doc") as JsonObject
let document = documentJsonObject == null ? null : new Document(documentJsonObject)
select new LuceneResultRow(id, fields, score, id, document)
).ToArray();
try
{
return new LuceneQueryResult(
query, rows, rows.Length, totalRows, offset, fetchDuration, searchDuration, limit, skip);
} catch (ArgumentOutOfRangeException e)
{
throw new ParseException(e);
}
}
public void ThrowLuceneIndexNotFoundExceptionIfNedded(LuceneQuery query)
{
if (statusCode == HttpStatusCode.NotFound && reason == Missing)
{
throw new LuceneIndexNotFoundException(query);
}
}
public void ShouldNotThrowAtAnyInput(string input)
{
LuceneQuery viewQuery = null;
Assert.DoesNotThrow(() => { viewQuery = ConvertFromString(input); });
Assert.Null(viewQuery);
}
private void button2_Click(object sender, EventArgs e)
{
//FSDirectory dir = FSDirectory.Open(PublicConst.LucenePath);
//IndexSearcher searcher = new IndexSearcher(dir);//查找器
//{
// TermQuery query = new TermQuery(new Term("Name", "配件"));//包含
// TopDocs docs = searcher.Search(query, null, 1000);//找到的数据
// foreach (ScoreDoc sd in docs.ScoreDocs)
// {
// Document doc = searcher.Doc(sd.Doc);
// Console.WriteLine("***************************************");
// Console.WriteLine(string.Format("Id={0}", doc.Get("Id")));
// Console.WriteLine(string.Format("Code={0}", doc.Get("Code")));
// Console.WriteLine(string.Format("PCode={0}", doc.Get("PCode")));
// Console.WriteLine(string.Format("Name={0}", doc.Get("Name")));
// Console.WriteLine(string.Format("Levels={0}", doc.Get("Levels")));
// }
// Console.WriteLine("一共命中了{0}个", docs.TotalHits);
//}
ILuceneQuery query = new LuceneQuery();
var list = query.QueryIndex("手机");
foreach (var item in list)
{
Console.WriteLine($"Title{item.Title} Price{item.Price} ProductId{item.ProductId} CateId{item.CateId} ");
}
}
/// <summary>Loads view request result from provided <see cref="TextReader"/>.</summary>
public static ILuceneQueryResult Parse(TextReader textReader, LuceneQuery query)
{
var response = ParseRawResponse(textReader);
var totalRows = GetTotalRows(response);
var offset = GetOffset(response);
var rawRows = GetRawRows(response);
var fetchDuration = TimeSpan.FromMilliseconds(response.GetPrimitiveProperty <int>("fetch_duration"));
var searchDuration = TimeSpan.FromMilliseconds(response.GetPrimitiveProperty <int>("search_duration"));
var limit = response.GetPrimitiveProperty <int>("limit");
var skip = response.GetPrimitiveProperty <int>("skip");
var rows = (
from rawRow in rawRows
let id = rawRow.GetPrimitiveProperty <string>("id")
let fields = rawRow.TryGetValue("fields")
let score = rawRow.GetPrimitiveProperty <decimal>("score")
let documentJsonObject = rawRow.TryGetValue("doc") as JsonObject
let document = documentJsonObject == null ? null : new Document(documentJsonObject)
select new LuceneResultRow(id, fields, score, id, document)
).ToArray();
try
{
return(new LuceneQueryResult(
query, rows, rows.Length, totalRows, offset, fetchDuration, searchDuration, limit, skip));
} catch (ArgumentOutOfRangeException e)
{
throw new ParseException(e);
}
}
public Task <ILuceneQueryResult> QueryLucene(LuceneQuery query)
{
return(Task.Factory.StartNew(() =>
{
Thread.Sleep(50); //preventing returning already done task
return Mock.Of <ILuceneQueryResult>(r => r.Count == 0 && r.Rows == new LuceneResultRow[0]);
}));
}
private void Init(LuceneQuery query, TimeSpan fetchDuration, TimeSpan searchDuration, int limit, int skip)
{
Query = query;
FetchDuration = fetchDuration;
SearchDuration = searchDuration;
Limit = limit;
Skip = skip;
}
public Task <ILuceneQueryResult> QueryLucene(LuceneQuery query)
{
if (query == null)
{
throw new ArgumentNullException("query");
}
using (SyncContext.SwitchToDefault())
return(QueryLuceneInternal(query));
}
async Task <ILuceneQueryResult <T> > QueryLuceneInternal <T>(LuceneQuery query, bool isEntityType)
{
var rawQueryResult = await databaseApi.QueryLucene(query);
if (!isEntityType)
{
return(rawQueryResult.OfType(DeserializeViewData <T, LuceneResultRow>));
}
UpdateUnitOfWork(rawQueryResult.Rows);
return(rawQueryResult.OfType(GetEntities <T, LuceneResultRow>));
}
async Task <ILuceneQueryResult> QueryLuceneInternal(LuceneQuery query)
{
var response = await StartQuery(uriConstructor.GetQueryUri(query));
if (!response.IsSuccessStatusCode)
{
var error = new CouchError(parent.Settings.Serializer, response);
error.ThrowDatabaseMissingExceptionIfNedded(uriConstructor);
error.ThrowLuceneIndexNotFoundExceptionIfNedded(query);
error.ThrowCouchCommunicationException();
}
using (var reader = await response.Content.ReadAsUtf8TextReaderAsync())
return(LuceneQueryResultParser.Parse(reader, query));
}
/// <summary>
/// Gets the extended results.
/// </summary>
/// <typeparam name="TSource">The type of the source.</typeparam>
/// <param name="source">The source.</param>
/// <returns></returns>
public static ExtendedSearchResults <TSource> GetExtendedResults <TSource>(this IQueryable <TSource> source) where TSource : SearchResultItem
{
Assert.ArgumentNotNull(source, "source");
var genQueryable = source.Provider as ExtendedGenericQueryable <TSource, LuceneQuery>;
Assert.IsNotNull(genQueryable, "Can't get queryable...");
var executeIndex = genQueryable.ExecuteIndex as LuceneIndex <TSource>;
Analyzer analyzer = executeIndex.Parameters.Analyzer;
IExecutionContext exContext = null;//Throws exception Sitecore 8 update 2. Pass null so field context is used to resolve Analyzer later: executeIndex.Parameters.ExecutionContext;
LuceneQuery luceneQuery = null;
SearchResults <TSource> results = genQueryable.Execute <SearchResults <TSource> >(Expression.Call(null, (getResultsMethod).MakeGenericMethod(new Type[] { typeof(TSource) }), new Expression[] { source.Expression }), out luceneQuery);
return(new ExtendedSearchResults <TSource>(results, luceneQuery.Query, analyzer, exContext));
}
private static string ConvertToString(LuceneQuery viewQuery, bool setDefaultDesignDocumentAndView = true)
{
if (setDefaultDesignDocumentAndView)
{
viewQuery.DesignDocumentName = "dd";
viewQuery.IndexName = "someIndex";
}
var converter = TypeDescriptor.GetConverter(typeof(LuceneQuery));
if (converter != null)
{
return((string)converter.ConvertTo(viewQuery, typeof(string)));
}
return(null);
}
/// <inheritdoc/>
public Task <ILuceneQueryResult <T> > QueryLucene <T>(LuceneQuery query)
{
if (query == null)
{
throw new ArgumentNullException("query");
}
var isEntityType = IsEntityType <T>();
if (isEntityType && !query.IncludeDocs)
{
throw CreateShouldUseIncludeDocsException();
}
WaitForFlushIfInProgress();
using (SyncContext.SwitchToDefault())
return(QueryLuceneInternal <T>(query, isEntityType));
}
private Task <Queries.IQueryResults> LuceneQueryApiAsync(LuceneQueryModel queryModel, bool returnContentItems = false)
{
var luceneQuery = new LuceneQuery
{
Index = queryModel.IndexName,
Template = queryModel.Query,
ReturnContentItems = returnContentItems
};
var queryParameters = queryModel.Parameters != null?
JsonConvert.DeserializeObject <Dictionary <string, object> >(queryModel.Parameters)
: new Dictionary <string, object>();
var result = _luceneQuerySource.ExecuteQueryAsync(luceneQuery, queryParameters);
return(result);
}
/// <summary>
/// 用lucene进行商品查询
/// </summary>
/// <param name="keyword"></param>
/// <param name="categoryIdList"></param>
/// <returns></returns>
public static List <Commodity> QueryCommodity(string keyword)
{
try
{
if (string.IsNullOrWhiteSpace(keyword))
{
return(null);
}
ILuceneQuery luceneQuery = new LuceneQuery();
string queryString = string.IsNullOrWhiteSpace(keyword) ? "" : string.Format(" +{0}", AnalyzerKeyword(keyword));
return(luceneQuery.QueryIndex(queryString));
}
catch (Exception ex)
{
logger.Error(string.Format("QueryCommodity参数为{0}出现异常", keyword), ex);
return(null);
}
}
public void LuceneController_Search_Request_For_PagIndex2_PageSize1_Returns_2nd_Record_Only()
{
//Arrange
AddStandardDocs();
var query = new LuceneQuery
{
Query = new TermQuery(new Term(Constants.ContentTag, "quick")), PageIndex = 2, PageSize = 1
};
var hits = _luceneController.Search(CreateSearchContext(query));
//Assert
Assert.AreEqual(3, hits.TotalHits);
Assert.AreEqual(1, hits.Results.Count());
// for some reason, this search's docs have scoring as
// Line1=0.3125, Line1=0.3125, Line2=0.3125, Line2=0.3750
Assert.AreEqual(Line1, hits.Results.ElementAt(0).Document.GetField(Constants.ContentTag).StringValue);
}
static void Main(string[] args)
{
do
{
Console.WriteLine("======================================================");
Console.WriteLine("分词列名：");
string fieldName = Console.ReadLine();
Console.WriteLine("查询的词：");
string keyword = Console.ReadLine();
Console.WriteLine();
CommodityRepository repository = new CommodityRepository();
//IList<EntryDataModel<Commodity>> entryDataModelList = repository.GetEntryDataModelList();
//IndexBuilderThread.BuildIndexThread<Commodity>(entryDataModelList);
ILuceneQuery <Commodity> luceneQuery = new LuceneQuery <Commodity>();
List <Commodity> modelList = luceneQuery.QueryIndex(keyword, fieldName, repository.GetFieldModelList());
ShowDataList(modelList);
} while (true);
}
public void LuceneController_Search_Single_FuzzyQuery()
{
// Arrange
string[] docs =
{
"fuzzy",
"wuzzy",
};
const string keyword = "wuzza";
this.AddLinesAsSearchDocs(docs);
// Act
var luceneQuery = new LuceneQuery {
Query = new FuzzyQuery(new Term(Constants.ContentTag, keyword))
};
var previews = this.luceneController.Search(this.CreateSearchContext(luceneQuery));
// Assert
Assert.AreEqual(2, previews.Results.Count());
}
/// <summary>
/// 用lucene进行商品查询
/// </summary>
/// <param name="pageIndex">从1开始</param>
/// <param name="pageSize">单页数量</param>
/// <param name="totalCount">总数</param>
/// <param name="keyword">搜索的关键字</param>
/// <param name="categoryIdList">类别集合</param>
/// <param name="priceFilter">[13,50] 13,50且包含13到50 {13,50} 13,50且不包含13到50</param>
/// <param name="priceOrderBy">price desc price asc</param>
/// <returns></returns>
public static List <Commodity> QueryCommodity(int pageIndex, int pageSize, out int totalCount, string keyword, List <int> categoryIdList, string priceFilter, string priceOrderBy)
{
totalCount = 0;
try
{
if (string.IsNullOrWhiteSpace(keyword) && (categoryIdList == null || categoryIdList.Count == 0))
{
return(null);
}
ILuceneQuery luceneQuery = new LuceneQuery();
string queryString = string.Format(" {0} {1}",
string.IsNullOrWhiteSpace(keyword) ? "" : string.Format(" +{0}", AnalyzerKeyword(keyword)),
categoryIdList == null || categoryIdList.Count == 0 ? "" : string.Format(" +{0}", AnalyzerCategory(categoryIdList)));
return(luceneQuery.QueryIndexPage(queryString, pageIndex, pageSize, out totalCount, priceFilter, priceOrderBy));
}
catch (Exception ex)
{
logger.Error(string.Format("QueryCommodity参数为{0}出现异常", keyword), ex);
return(null);
}
}
protected override NameValueCollection GetQueryString()
{
var queryString = base.GetQueryString();
queryString["ignoreFilter"] = IgnoreFilter.ToString();
queryString["CountOnly"] = CountOnly.ToString();
if (Skip.HasValue)
{
queryString["Skip"] = Skip.ToString();
}
if (Take.HasValue)
{
queryString["Take"] = Take.ToString();
}
if (IncludeSemVer2)
{
queryString["semVerLevel"] = "2.0.0";
}
if (!string.IsNullOrWhiteSpace(SortBy))
{
queryString["sortBy"] = SortBy;
}
if (LuceneQuery.HasValue)
{
queryString["luceneQuery"] = LuceneQuery.ToString();
}
if (PackageType != null)
{
queryString["packageType"] = PackageType;
}
return(queryString);
}
/// <summary>
/// 用lucene进行商品查询
/// </summary>
/// <param name="pageIndex"></param>
/// <param name="pageSize"></param>
/// <param name="totalCount"></param>
/// <param name="keyword"></param>
/// <param name="fieldName"></param>
/// <param name="categoryIdList"></param>
/// <param name="priceFilter">[13,50] 13,50且包含13到50 {13,50} 13,50且不包含13到50</param>
/// <param name="priceOrderBy">price desc price asc</param>
/// <param name="fieldModelList"></param>
/// <returns></returns>
public static List <T> QueryCommodity <T>(int pageIndex, int pageSize, out int totalCount, string keyword, string fieldName, List <int> categoryIdList, Filter filter, Sort sort, IList <FieldDataModel> fieldModelList) where T : class, new()
{
totalCount = 0;
List <T> modelList = null;
try
{
if (string.IsNullOrWhiteSpace(keyword) && (categoryIdList == null || categoryIdList.Count == 0))
{
return(null);
}
ILuceneQuery <T> luceneQuery = new LuceneQuery <T>();
string analyzerKeyword = string.IsNullOrWhiteSpace(keyword) ? "" : string.Format(" +{0}", AnalyzerKeyword(keyword, fieldName));
string queryString = string.Format(" {0} ", analyzerKeyword);
modelList = luceneQuery.QueryIndexPage(queryString, fieldName, pageIndex, pageSize, out totalCount, filter, sort, fieldModelList);
}
catch (Exception ex)
{
m_logger.Error(string.Format("QueryCommodity参数为{0}出现异常", keyword), ex);
}
return(modelList);
}
public void LuceneController_Search_Single_FuzzyQuery()
{
//Arrange
string[] docs =
{
"fuzzy",
"wuzzy"
};
const string keyword = "wuzza";
AddLinesAsSearchDocs(docs);
int totalHits;
//Act
var luceneQuery = new LuceneQuery {
Query = new FuzzyQuery(new Term(Constants.ContentTag, keyword))
};
var previews = _luceneController.Search(luceneQuery, out totalHits);
//Assert
Assert.AreEqual(2, previews.Count());
}
public async Task <IActionResult> Documents(
string indexName,
string query,
string parameters)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.QueryLuceneApi))
{
return(this.ChallengeOrForbid("Api"));
}
var luceneQuery = new LuceneQuery
{
Index = indexName,
Template = query
};
var queryParameters = parameters != null?
JsonConvert.DeserializeObject <Dictionary <string, object> >(parameters)
: new Dictionary <string, object>();
var result = await _luceneQuerySource.ExecuteQueryAsync(luceneQuery, queryParameters);
return(new ObjectResult(result.Items));
}
public Task<ILuceneQueryResult> QueryLucene(LuceneQuery query)
{
return Task.Factory.StartNew(() =>
{
Thread.Sleep(50); //preventing returning already done task
return Mock.Of<ILuceneQueryResult>(r => r.Count == 0 && r.Rows == new LuceneResultRow[0]);
});
}
internal static bool TryParse(Uri uri, out LuceneQuery viewQuery)
{
if (uri.IsAbsoluteUri)
{
viewQuery = null;
return false;
}
var match = Regex.Match(
uri.ToString(), "^_design/(?<designDocName>.*?)/(?<indexName>.*?)(?:\\?(?<queryString>.*))?$");
if (match.Success)
{
viewQuery = new LuceneQuery {
DesignDocumentName = match.Groups["designDocName"].Value,
IndexName = match.Groups["indexName"].Value
};
var queryStringGroup = match.Groups["queryString"];
if (queryStringGroup.Success)
OptionListSerializer.Parse(queryStringGroup.Value, ref viewQuery);
return true;
}
viewQuery = null;
return false;
}
private static string ConvertToString(LuceneQuery viewQuery, bool setDefaultDesignDocumentAndView = true)
{
if (setDefaultDesignDocumentAndView)
{
viewQuery.DesignDocumentName = "dd";
viewQuery.IndexName = "someIndex";
}
var converter = TypeDescriptor.GetConverter(typeof(LuceneQuery));
if (converter != null)
return (string) converter.ConvertTo(viewQuery, typeof (string));
return null;
}
internal static Uri ToUri(LuceneQuery viewQuery, ISerializer serializer = null)
{
var uriString = ToUriString(viewQuery, serializer);
return uriString == null? null: new Uri(uriString, UriKind.Relative);
}
internal static string ToUriString(LuceneQuery viewQuery, ISerializer serializer = null)
{
if (viewQuery.DesignDocumentName.HasNoValue() || viewQuery.IndexName.HasNoValue())
return null;
if (serializer == null)
serializer = new NewtonsoftSerializer();
var uri = new StringBuilder();
uri.Append("_design/")
.Append(viewQuery.DesignDocumentName)
.Append("/")
.Append(viewQuery.IndexName);
var queryString = OptionListSerializer.ToQueryString(viewQuery, serializer);
if (queryString.Length > 0)
uri.Append("?").Append(queryString);
return uri.ToString();
}
public ILuceneQueryResult QueryLucene(LuceneQuery query)
{
return databaseApi.QueryLucene(query).WaitForResult();
}
public Task<ILuceneQueryResult> QueryLucene(LuceneQuery query)
{
if (query == null) throw new ArgumentNullException("query");
using (SyncContext.SwitchToDefault())
return QueryLuceneInternal(query);
}
async Task<ILuceneQueryResult> QueryLuceneInternal(LuceneQuery query)
{
var response = await StartQuery(uriConstructor.GetQueryUri(query));
if (!response.IsSuccessStatusCode)
{
var error = new CouchError(parent.Settings.Serializer, response);
error.ThrowDatabaseMissingExceptionIfNedded(uriConstructor);
error.ThrowLuceneIndexNotFoundExceptionIfNedded(query);
error.ThrowCouchCommunicationException();
}
using (var reader = await response.Content.ReadAsUtf8TextReaderAsync())
return LuceneQueryResultParser.Parse(reader, query);
}
public Uri GetQueryUri(LuceneQuery query)
{
var sectionFtiBaseUri = new Uri(databaseFtiEndpoint, query.SectionName + "/");
var databaseFtiBaseUri = new Uri(sectionFtiBaseUri, databaseNameWithSlash);
return new Uri(databaseFtiBaseUri, query.ToUri());
}
internal static bool TryParse(string uriString, out LuceneQuery viewQuery)
{
Uri uri;
viewQuery = null;
return Uri.TryCreate(uriString, UriKind.Relative, out uri) && TryParse(uri, out viewQuery);
}
private LuceneSearchContext CreateSearchContext(LuceneQuery luceneQuery)
{
return(new LuceneSearchContext {
LuceneQuery = luceneQuery, SearchQuery = this.mockSearchQuery.Object
});
}
public void ThrowLuceneIndexNotFoundExceptionIfNedded(LuceneQuery query)
{
if (statusCode == HttpStatusCode.NotFound && reason == Missing)
throw new LuceneIndexNotFoundException(query);
}
