public static BooleanOperation ToBooleanOperation(this BooleanClause.Occur o)
{
return(Examine.LuceneEngine.SearchCriteria.LuceneSearchExtensions.ToBooleanOperation(o));
}
internal LuceneQuery(LuceneSearchCriteria search, BooleanClause.Occur occurance)
{
this.search = search;
this.occurance = occurance;
}
protected internal IBooleanOperation NodeTypeAliasInternal(IExamineValue examineValue, BooleanClause.Occur occurance)
{
//force lower case
var eVal = new ExamineValue(examineValue.Examineness, examineValue.Value.ToLower(), examineValue.Level);
//don't use the query parser for this operation, it needs to match exact
return(this.FieldInternal(NodeTypeAliasField, eVal, occurance, false));
}
protected void ApplyDateRangeSearchParam(BooleanQuery query, DateRangeSearchParam param, BooleanClause.Occur innerOccurance)
{
if (param.Ranges.Count <= 0)
{
return;
}
foreach (var dateParam in param.Ranges)
{
AddDateRangeQuery(query, dateParam, innerOccurance);
}
}
protected void AddDateRangeQuery(BooleanQuery query, DateRange dateRangeField, BooleanClause.Occur occurance)
{
var startDateTime = dateRangeField.StartDate;
var endDateTime = dateRangeField.EndDate;
if (dateRangeField.InclusiveStart && startDateTime > DateTime.MinValue.AddDays(1))
{
startDateTime = startDateTime.AddDays(-1);
}
if (dateRangeField.InclusiveEnd && endDateTime < DateTime.MaxValue.AddDays(-1))
{
endDateTime = endDateTime.AddDays(1);
}
// converting to lucene format
var startDate = DateTools.DateToString(startDateTime, DateTools.Resolution.DAY);
var endDate = DateTools.DateToString(endDateTime, DateTools.Resolution.DAY);
var rangeQuery = new RangeQuery(new Term(dateRangeField.FieldName, startDate), new Term(dateRangeField.FieldName, endDate), true);
query.Add(rangeQuery, occurance);
}
internal static void AddDateRangeQuery(BooleanQuery query, DateRangeSearchParam.DateRangeField dateRangeField, BooleanClause.Occur occurance)
{
var startDateTime = dateRangeField.StartDate;
if (dateRangeField.InclusiveStart)
{
if (startDateTime != DateTime.MinValue)
{
startDateTime.ChangeTime(0, 0, 0, 0);
}
}
var endDateTime = dateRangeField.EndDate;
if (dateRangeField.InclusiveStart)
{
if (endDateTime != DateTime.MaxValue)
{
endDateTime = endDateTime.ChangeTime(23, 59, 59, 59);
}
}
BooleanQuery.SetMaxClauseCount(int.MaxValue);
if (!(dateRangeField.StartDate == DateTime.MinValue && dateRangeField.EndDate == DateTime.MaxValue))
{
query.Add(new RangeQuery(new Term(SearchFieldIDs.CreatedDate, startDateTime.ToString("yyyyMMdd")), new Term(SearchFieldIDs.CreatedDate, endDateTime.ToString("yyyyMMdd")), true), occurance);
}
}
protected void ApplyNumericRangeSearchParam(BooleanQuery query, NumericRangeSearchParam param, BooleanClause.Occur innerOccurance)
{
if (param.Ranges.Count <= 0)
{
return;
}
foreach (var range in param.Ranges)
{
AddNumericRangeQuery(query, range, innerOccurance);
}
}
protected internal IBooleanOperation RangeInternal(string fieldName, int start, int end, bool includeLower, bool includeUpper, BooleanClause.Occur occurance)
{
query.Add(NumericRangeQuery.NewIntRange(fieldName, start, end, includeLower, includeUpper), occurance);
return(new LuceneBooleanOperation(this));
}
/// <summary>
/// Creates our own style 'multi field query' used internal for the grouped operations
/// </summary>
/// <param name="fields"></param>
/// <param name="fieldVals"></param>
/// <param name="occurance"></param>
/// <returns>A new <see cref="Examine.SearchCriteria.IBooleanOperation"/> with the clause appended</returns>
protected internal BooleanQuery GetMultiFieldQuery(string[] fields, IExamineValue[] fieldVals, BooleanClause.Occur occurance)
{
//if there's only 1 query text we want to build up a string like this:
//(!field1:query !field2:query !field3:query)
//but Lucene will bork if you provide an array of length 1 (which is != to the field length)
var queryVals = new IExamineValue[fields.Length];
if (fieldVals.Length == 1)
{
for (int i = 0; i < queryVals.Length; i++)
{
queryVals[i] = fieldVals[0];
}
}
else
{
queryVals = fieldVals;
}
var qry = new BooleanQuery();
for (int i = 0; i < fields.Length; i++)
{
qry.Add(this.GetFieldInternalQuery(fields[i], queryVals[i]), occurance);
}
return(qry);
}
protected override Query BuildQuery(BooleanClause.Occur condition)
{
return(QueryBuilder.BuildDateRangeSearchParam(this.Ranges, condition));
}
internal protected IBooleanOperation NodeTypeAliasInternal(IExamineValue examineValue, BooleanClause.Occur occurance)
{
return(this.FieldInternal("nodeTypeAlias", examineValue, occurance));
}
/// <summary>Builds a new BooleanClause instance</summary>
/// <param name="q">sub query</param>
/// <param name="occur">how this clause should occur when matching documents</param>
/// <returns> new BooleanClause instance</returns>
protected internal virtual BooleanClause NewBooleanClause(Query q, BooleanClause.Occur occur)
{
return(new BooleanClause(q, occur));
}
/// <exception cref="ParseException">throw in overridden method to disallow</exception>
protected internal virtual Query NewFieldQuery(Analyzer analyzer, string field, string queryText, bool quoted)
{
BooleanClause.Occur occur = DefaultOperator == Operator.AND ? BooleanClause.Occur.MUST : BooleanClause.Occur.SHOULD;
return(CreateFieldQuery(analyzer, occur, field, queryText, quoted || AutoGeneratePhraseQueries, PhraseSlop));
}
/// <summary>
/// 关键词搜索
/// </summary>
/// <param name="q">关键词</param>
/// <param name="pageLen">条数</param>
/// <param name="pageNo">页码</param>
/// <param name="recCount">总记录数</param>
/// <returns>搜索结果</returns>
public override JXSearchEntityResult Search(string q, int pageLen, int pageNo, out int recCount)
{
IndexSearcher search = new IndexSearcher(CURR_INDEX_DIR);
// 关键词检索字段
string[] fields = { "ChineseName", "PinyinName" };
BooleanClause.Occur[] flags = new BooleanClause.Occur[fields.Length];
for (int n = 0; n < fields.Length; n++)
{
flags[n] = BooleanClause.Occur.SHOULD;
}
// 关键词检索
// BooleanClause.Occur.MUST 表示 and
// BooleanClause.Occur.MUST_NOT 表示 not
// BooleanClause.Occur.SHOULD 表示 or
q = GetKeyWordsSplitBySpace(q, new PanGuTokenizer());
Query query1 = MultiFieldQueryParser.Parse(Lucene.Net.Util.Version.LUCENE_29, q, fields, flags, new PanGuAnalyzer(true));
BooleanQuery query = new BooleanQuery();
query.Add(query1, BooleanClause.Occur.MUST);
// 查询
Hits hits = search.Search(query);
// 绑定
recCount = hits.Length(); // 总记录数
int i = (pageNo - 1) * pageLen;
List <JXSearchEntity> result = new List <JXSearchEntity>();
while (i < recCount && result.Count < pageLen)
{
JXSearchEntity info = null;
try
{
info = new JXSearchEntity();
info.id = int.Parse(hits.Doc(i).Get("KeywordID"));
info.chineseName = hits.Doc(i).Get("ChineseName");
info.productCount = int.Parse(hits.Doc(i).Get("ProductCount"));
info.typeID = int.Parse(hits.Doc(i).Get("TypeID"));
}
catch { }
finally
{
if (info != null)
{
result.Add(info);
}
i++;
}
}
// 关闭搜索
search.Close();
// 返回
if (result == null || result.Count <= 0)
{
return(null);
}
else
{
return(new JXSearchEntityResult()
{
listKeyword = result,
totalPage = Convert.ToInt32(Math.Ceiling((double)recCount / pageLen)),
resultCode = "SUCCEED",
resultMsg = "SUCCEED"
});
};
}
/// <summary>
/// Create a new FilterClause </summary>
/// <param name="filter"> A Filter object containing a BitSet </param>
/// <param name="occur"> A parameter implementation indicating SHOULD, MUST or MUST NOT </param>
public FilterClause(Filter filter, BooleanClause.Occur occur)
{
this.occur = occur;
this.filter = filter;
}
internal protected IBooleanOperation FieldInternal(string fieldName, IExamineValue fieldValue, BooleanClause.Occur occurance)
{
return(FieldInternal(fieldName, fieldValue, occurance, true));
}
internal static void ApplyDateRangeSearchParam(BooleanQuery query, DateRangeSearchParam param, BooleanClause.Occur innerOccurance)
{
if (param.Ranges == null)
{
return;
}
if (param.Ranges.Count <= 0)
{
return;
}
param.Ranges.ForEach(dateParam => AddDateRangeQuery(query, dateParam, innerOccurance));
}
internal protected IBooleanOperation FieldInternal(string fieldName, IExamineValue fieldValue, BooleanClause.Occur occurance, bool useQueryParser)
{
Query queryToAdd = GetFieldInternalQuery(fieldName, fieldValue, useQueryParser);
if (queryToAdd != null)
{
Query.Add(queryToAdd, occurance);
}
return(new LuceneBooleanOperation(this));
}
protected abstract Query BuildQuery(BooleanClause.Occur innerCondition);
protected internal IBooleanOperation RangeInternal(string fieldName, long lower, long upper, bool includeLower, bool includeUpper, BooleanClause.Occur occurance)
{
Query.Add(NumericRangeQuery.NewLongRange(fieldName, lower, upper, includeLower, includeUpper), occurance);
return(new LuceneBooleanOperation(this));
}
protected void AddNumericRangeQuery(BooleanQuery query, NumericRangeSearchParam.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);
}
protected internal IBooleanOperation RangeInternal(string fieldName, string start, string end, bool includeLower, bool includeUpper, BooleanClause.Occur occurance)
{
Query.Add(new TermRangeQuery(fieldName, start, end, includeLower, includeUpper), occurance);
return(new LuceneBooleanOperation(this));
}
protected void AddDateRangeQuery(BooleanQuery query, DateRangeSearchParam.DateRangeField dateRangeField, BooleanClause.Occur occurance)
{
var startDateTime = dateRangeField.StartDate;
if (dateRangeField.InclusiveStart)
{
startDateTime = startDateTime.AddDays(1);
}
var startDate = startDateTime.ToString(IndexConstants.DateTimeFormat);
var endDateTime = dateRangeField.EndDate;
if (dateRangeField.InclusiveStart)
{
endDateTime = endDateTime.AddDays(1);
}
var endDate = endDateTime.ToString(IndexConstants.DateTimeFormat);
var rangeQuery = new RangeQuery(new Term(dateRangeField.FieldName, startDate), new Term(dateRangeField.FieldName, endDate), true);
query.Add(rangeQuery, occurance);
}
protected internal IBooleanOperation GroupedOrInternal(string[] fields, IExamineValue[] fieldVals, BooleanClause.Occur occurance)
{
//if there's only 1 query text we want to build up a string like this:
//(field1:query field2:query field3:query)
//but Lucene will bork if you provide an array of length 1 (which is != to the field length)
Query.Add(GetMultiFieldQuery(fields, fieldVals, BooleanClause.Occur.SHOULD, true), occurance);
return(new LuceneBooleanOperation(this));
}
private void AddBooleanClause(BooleanQuery boolQuery, Query query, BooleanClause.Occur occur)
{
var boolQ = query as BooleanQuery;
if (boolQ == null)
{
boolQuery.Add(new BooleanClause(query, occur));
return;
}
var clauses = boolQ.GetClauses();
if (clauses.Length == 0)
{
throw ParserError("Empty BooleanQuery");
}
if (clauses.Length > 1)
{
boolQuery.Add(new BooleanClause(query, occur));
return;
}
//-- boolQ has one clause: combine occurs
var clause = (BooleanClause)clauses[0];
var clauseOccur = clause.GetOccur();
BooleanClause.Occur effectiveOccur;
if (Operator == DefaultOperator.Or)
{
// in cl eff
// null _ ==> _
// null + ==> +
// null - ==> -
// _ _ ==> _
// _ + ==> +
// _ - ==> -
// + _ ==> +
// + + ==> +
// + - ==> -
// - _ ==> -
// - + ==> -
// - - ==> -
if (occur == null || occur == BooleanClause.Occur.SHOULD)
{
effectiveOccur = clauseOccur;
}
else if (occur == BooleanClause.Occur.MUST_NOT)
{
effectiveOccur = occur;
}
else if (clauseOccur == BooleanClause.Occur.MUST_NOT)
{
effectiveOccur = clauseOccur;
}
else
{
effectiveOccur = occur;
}
}
else
{
// in cl eff
// null _ ==> _
// null + ==> +
// null - ==> -
// _ _ ==> _
// _ + ==> _
// _ - ==> -
// + _ ==> +
// + + ==> +
// + - ==> -
// - _ ==> -
// - + ==> -
// - - ==> -
if (occur == null)
{
effectiveOccur = clauseOccur;
}
else if (occur == BooleanClause.Occur.MUST_NOT)
{
effectiveOccur = occur;
}
else if (clauseOccur == BooleanClause.Occur.MUST_NOT)
{
effectiveOccur = clauseOccur;
}
else
{
effectiveOccur = occur;
}
}
clause.SetOccur(effectiveOccur);
boolQuery.Add(clause);
}
protected internal IBooleanOperation GroupedFlexibleInternal(string[] fields, BooleanOperation[] operations, IExamineValue[] fieldVals, BooleanClause.Occur occurance)
{
//if there's only 1 query text we want to build up a string like this:
//(field1:query field2:query field3:query)
//but Lucene will bork if you provide an array of length 1 (which is != to the field length)
var flags = new BooleanClause.Occur[operations.Count()];
for (int i = 0; i < flags.Length; i++)
{
flags[i] = operations.ElementAt(i).ToLuceneOccurance();
}
var queryVals = new IExamineValue[fields.Length];
if (fieldVals.Length == 1)
{
for (int i = 0; i < queryVals.Length; i++)
{
queryVals[i] = fieldVals[0];
}
}
else
{
queryVals = fieldVals;
}
var qry = new BooleanQuery();
for (int i = 0; i < fields.Length; i++)
{
var q = GetFieldInternalQuery(fields[i], queryVals[i], true);
if (q != null)
{
qry.Add(q, flags[i]);
}
}
this.Query.Add(qry, occurance);
return(new LuceneBooleanOperation(this));
}
protected internal IBooleanOperation NodeNameInternal(IExamineValue examineValue, BooleanClause.Occur occurance)
{
return(this.FieldInternal(NodeNameField, examineValue, occurance));
}
/// <summary>
/// 关键词多条件搜索
/// </summary>
/// <param name="keyword">关键词</param>
/// <param name="brand">品牌</param>
/// <param name="cfid">分类</param>
/// <param name="pricelimit">价格区间</param>
/// <param name="store">是否有货</param>
/// <param name="order">排序</param>
/// <param name="recCount">总记录数</param>
/// <param name="pageLen">条数</param>
/// <param name="pageNo">页码</param>
/// <returns>搜索结果</returns>
public override JXSearchProductResult Search(RequestForm form, out int recCount)
{
recCount = 0;
JXSearchProductResult result = new JXSearchProductResult();
IndexSearcher search = new IndexSearcher(CURR_INDEX_DIR);
try
{
#region 搜索条件
Query query1 = null;
BooleanQuery query = new BooleanQuery();
if (StringUtil.IsNatural_Number(form.queryForm.keyword))
{
// 商品ID、金象码、拼音
BooleanClause.Occur[] flags = new BooleanClause.Occur[fieldsAbbr.Length];
for (int n = 0; n < fieldsAbbr.Length; n++)
{
flags[n] = BooleanClause.Occur.SHOULD;
}
query1 = MultiFieldQueryParser.Parse(Lucene.Net.Util.Version.LUCENE_29, form.queryForm.keyword, fieldsAbbr, flags, new PanGuAnalyzer(true));
query.Add(query1, BooleanClause.Occur.MUST);
}
else
{
// 关键词检索字段\t\r\n\\t
BooleanClause.Occur[] flags = new BooleanClause.Occur[fields.Length];
for (int n = 0; n < fields.Length; n++)
{
flags[n] = BooleanClause.Occur.SHOULD;
}
// 转换关键词拼音
string pinyinName = PinyinUtil.ConvertToPinyin(GetKeyWordsSplitFilter(form.queryForm.keyword, new PanGuTokenizer()));
// 关键词检索
// BooleanClause.Occur.MUST 表示 and
// BooleanClause.Occur.MUST_NOT 表示 not
// BooleanClause.Occur.SHOULD 表示 or
string q = GetKeyWordsSplitBySpace(string.Format("{0} {1}", form.queryForm.keyword, pinyinName), new PanGuTokenizer());
query1 = MultiFieldQueryParser.Parse(Lucene.Net.Util.Version.LUCENE_29, q, fields, flags, new PanGuAnalyzer(true));
query.Add(query1, BooleanClause.Occur.MUST);
}
// 品牌
if (form.queryForm.brandIds != null && form.queryForm.brandIds.Count() > 0)
{
BooleanQuery tmpBQ = new BooleanQuery();
foreach (int key in form.queryForm.brandIds)
{
tmpBQ.Add(new TermQuery(new Term("BrandID", key.ToString())), BooleanClause.Occur.SHOULD);
}
query.Add(tmpBQ, BooleanClause.Occur.MUST);
}
// 分类
if (form.queryForm.cfid > 0)
{
BooleanQuery tmpBQ = new BooleanQuery();
tmpBQ.Add(new TermQuery(new Term("CFID1", form.queryForm.cfid.ToString())), BooleanClause.Occur.SHOULD);
tmpBQ.Add(new TermQuery(new Term("CFID2", form.queryForm.cfid.ToString())), BooleanClause.Occur.SHOULD);
tmpBQ.Add(new TermQuery(new Term("CFID3", form.queryForm.cfid.ToString())), BooleanClause.Occur.SHOULD);
query.Add(tmpBQ, BooleanClause.Occur.MUST);
}
// 库存
if (form.queryForm.stock > 0)
{
query.Add(new TermQuery(new Term("Stock", "1")), BooleanClause.Occur.MUST);
}
// 价格区间
if (!string.IsNullOrEmpty(form.queryForm.pricelimit))
{
string[] price = form.queryForm.pricelimit.Split(",".ToCharArray());
if (price.Length > 0 && double.Parse(price[1]) > 0)
{
query.Add(NumericRangeQuery.NewDoubleRange("TradePrice", double.Parse(price[0]), double.Parse(price[1]), true, false), BooleanClause.Occur.MUST);
}
}
// 是否有货 Selling 是否在卖 1：在卖 0：下架 2：暂无库存
if (form.queryForm.store == 1)
{
query.Add(new TermQuery(new Term("Selling", form.queryForm.store.ToString())), BooleanClause.Occur.MUST);
}
Hits hits = search.Search(query);
#endregion
// 构造商品结果
result.listProductList = ProductBinding(hits, form.queryForm.keyword, form.queryForm.order, form.pageForm.page, form.pageForm.size, out recCount);
#region 构造结果参数 品牌/分类
// 排除搜索条件重新搜索
if ((form.queryForm.brandIds != null && form.queryForm.brandIds.Count() > 0) || form.queryForm.cfid > 0 || form.queryForm.store == 1 || form.queryForm.order > 0 || !string.IsNullOrEmpty(form.queryForm.pricelimit))
{
BooleanQuery booleanQuery = new BooleanQuery();
booleanQuery.Add(query1, BooleanClause.Occur.MUST);
hits = search.Search(query);
}
// 构造分类、品牌结果
IList <JXSearchEntity> list = ProductParaList(hits);
if (list != null)
{
// 品牌
result.listBrand = list.Where(g => g.typeID == 5).ToList();
// 一级分类
IList <JXSearchEntity> categoryList = list.Where(g => g.typeID == 2 && g.parentID == 0).ToList();
if (categoryList != null)
{
foreach (JXSearchEntity item in categoryList)
{
// 二级分类
item.listSubClassification = list.Where(g => g.typeID == 2 && g.parentID == item.id).ToList();
foreach (JXSearchEntity subItem in item.listSubClassification)
{
// 三级分类
subItem.listSubClassification = list.Where(g => g.typeID == 2 && g.parentID == subItem.id).ToList();
}
}
}
result.listClassification = categoryList;
}
#endregion
// 页数
result.totalPage = Convert.ToInt32(Math.Ceiling((double)recCount / form.pageForm.size));
result.resultCode = "SUCCEED";
result.resultMsg = "SUCCEED";
}
catch { }
finally
{
search.Close();
search.Dispose();
}
return(result);
}
protected internal IBooleanOperation ParentIdInternal(int id, BooleanClause.Occur occurance)
{
Query.Add(this.QueryParser.GetFieldQuery(ParentIdField, id.ToString()), occurance);
return(new LuceneBooleanOperation(this));
}
public ExtendedCommonTermsQuery(BooleanClause.Occur highFreqOccur, BooleanClause.Occur lowFreqOccur, float maxTermFrequency)
: base(highFreqOccur, lowFreqOccur, maxTermFrequency)
{
}
