/*(non-Javadoc) @see Mono.Lucene.Net.Search.Query#rewrite(Mono.Lucene.Net.Index.IndexReader) */
public override Query Rewrite(IndexReader reader)
{
CustomScoreQuery clone = null;
Query sq = subQuery.Rewrite(reader);
if (sq != subQuery)
{
clone = (CustomScoreQuery)Clone();
clone.subQuery = sq;
}
for (int i = 0; i < valSrcQueries.Length; i++)
{
ValueSourceQuery v = (ValueSourceQuery)valSrcQueries[i].Rewrite(reader);
if (v != valSrcQueries[i])
{
if (clone == null)
{
clone = (CustomScoreQuery)Clone();
}
clone.valSrcQueries[i] = v;
}
}
return((clone == null) ? this : clone);
}
/// <summary> Query should be rewritten for wild/fuzzy support.
///
/// </summary>
/// <param name="query">
/// </param>
/// <returns> payloads Collection
/// </returns>
/// <throws> IOException </throws>
public virtual ICollection <byte[]> GetPayloadsForQuery(Query query)
{
ICollection <byte[]> payloads = new List <byte[]>();
QueryToSpanQuery(query, payloads);
return(payloads);
}
/// <summary> Create a CustomScoreQuery over input subQuery and a {@link ValueSourceQuery}.</summary>
/// <param name="subQuery">the sub query whose score is being customized. Must not be null.
/// </param>
/// <param name="valSrcQueries">value source queries whose scores are used in the custom score
/// computation. For most simple/convenient use case these would be
/// {@link Mono.Lucene.Net.Search.Function.FieldScoreQuery FieldScoreQueries}.
/// This parameter is optional - it can be null or even an empty array.
/// </param>
public CustomScoreQuery(Query subQuery, ValueSourceQuery[] valSrcQueries)
{
this.subQuery = subQuery;
this.valSrcQueries = valSrcQueries != null?valSrcQueries:new ValueSourceQuery[0];
if (subQuery == null)
throw new System.ArgumentException("<subquery> must not be null!");
}
/// <summary> Create a CustomScoreQuery over input subQuery and a {@link ValueSourceQuery}.</summary>
/// <param name="subQuery">the sub query whose score is being customized. Must not be null.
/// </param>
/// <param name="valSrcQueries">value source queries whose scores are used in the custom score
/// computation. For most simple/convenient use case these would be
/// {@link Mono.Lucene.Net.Search.Function.FieldScoreQuery FieldScoreQueries}.
/// This parameter is optional - it can be null or even an empty array.
/// </param>
public CustomScoreQuery(Query subQuery, ValueSourceQuery[] valSrcQueries)
{
this.subQuery = subQuery;
this.valSrcQueries = valSrcQueries != null?valSrcQueries:new ValueSourceQuery[0];
if (subQuery == null)
{
throw new System.ArgumentException("<subquery> must not be null!");
}
}
private void ApplySlop(Query q, int slop)
{
if (q is PhraseQuery)
{
((PhraseQuery)q).SetSlop(slop);
}
else if (q is MultiPhraseQuery)
{
((MultiPhraseQuery)q).SetSlop(slop);
}
}
/// <summary> Parses a query, searching on the fields specified. Use this if you need
/// to specify certain fields as required, and others as prohibited.
/// <p/>
///
/// <pre>
/// Usage:
/// <code>
/// String[] query = {"query1", "query2", "query3"};
/// String[] fields = {"filename", "contents", "description"};
/// BooleanClause.Occur[] flags = {BooleanClause.Occur.SHOULD,
/// BooleanClause.Occur.MUST,
/// BooleanClause.Occur.MUST_NOT};
/// MultiFieldQueryParser.parse(query, fields, flags, analyzer);
/// </code>
/// </pre>
/// <p/>
/// The code above would construct a query:
///
/// <pre>
/// <code>
/// (filename:query1) +(contents:query2) -(description:query3)
/// </code>
/// </pre>
///
/// </summary>
/// <param name="matchVersion">Lucene version to match; this is passed through to
/// QueryParser.
/// </param>
/// <param name="queries">Queries string to parse
/// </param>
/// <param name="fields">Fields to search on
/// </param>
/// <param name="flags">Flags describing the fields
/// </param>
/// <param name="analyzer">Analyzer to use
/// </param>
/// <throws> ParseException </throws>
/// <summary> if query parsing fails
/// </summary>
/// <throws> IllegalArgumentException </throws>
/// <summary> if the length of the queries, fields, and flags array differ
/// </summary>
public static Query Parse(Version matchVersion, System.String[] queries, System.String[] fields, BooleanClause.Occur[] flags, Analyzer analyzer)
{
if (!(queries.Length == fields.Length && queries.Length == flags.Length))
{
throw new System.ArgumentException("queries, fields, and flags array have have different length");
}
BooleanQuery bQuery = new BooleanQuery();
for (int i = 0; i < fields.Length; i++)
{
QueryParser qp = new QueryParser(matchVersion, fields[i], analyzer);
Query q = qp.Parse(queries[i]);
if (q != null && (!(q is BooleanQuery) || ((BooleanQuery)q).GetClauses().Length > 0))
{
bQuery.Add(q, flags[i]);
}
}
return(bQuery);
}
protected internal override Query GetFieldQuery(System.String field, System.String queryText, int slop)
{
if (field == null)
{
System.Collections.IList clauses = new System.Collections.ArrayList();
for (int i = 0; i < fields.Length; i++)
{
Query q = base.GetFieldQuery(fields[i], queryText);
if (q != null)
{
//If the user passes a map of boosts
if (boosts != null)
{
//Get the boost from the map and apply them
if (boosts.Contains(fields[i]))
{
System.Single boost = (System.Single)boosts[fields[i]];
q.SetBoost((float)boost);
}
}
ApplySlop(q, slop);
clauses.Add(new BooleanClause(q, BooleanClause.Occur.SHOULD));
}
}
if (clauses.Count == 0)
{
// happens for stopwords
return(null);
}
return(GetBooleanQuery(clauses, true));
}
Query q2 = base.GetFieldQuery(field, queryText);
ApplySlop(q2, slop);
return(q2);
}
/// <summary> Create a CustomScoreQuery over input subQuery and a {@link ValueSourceQuery}.</summary>
/// <param name="subQuery">the sub query whose score is being customed. Must not be null.
/// </param>
/// <param name="valSrcQuery">a value source query whose scores are used in the custom score
/// computation. For most simple/convineient use case this would be a
/// {@link Mono.Lucene.Net.Search.Function.FieldScoreQuery FieldScoreQuery}.
/// This parameter is optional - it can be null or even an empty array.
/// </param>
public CustomScoreQuery(Query subQuery, ValueSourceQuery valSrcQuery):this(subQuery, valSrcQuery != null?new ValueSourceQuery[]{valSrcQuery}:new ValueSourceQuery[0])
{
}
/// <summary> Create a CustomScoreQuery over input subQuery and a {@link ValueSourceQuery}.</summary>
/// <param name="subQuery">the sub query whose score is being customed. Must not be null.
/// </param>
/// <param name="valSrcQuery">a value source query whose scores are used in the custom score
/// computation. For most simple/convineient use case this would be a
/// {@link Mono.Lucene.Net.Search.Function.FieldScoreQuery FieldScoreQuery}.
/// This parameter is optional - it can be null or even an empty array.
/// </param>
public CustomScoreQuery(Query subQuery, ValueSourceQuery valSrcQuery) : this(subQuery, valSrcQuery != null?new ValueSourceQuery[] { valSrcQuery }:new ValueSourceQuery[0])
{
}
internal bool BufferDeleteQueries(Query[] queries)
{
lock (this)
{
WaitReady(null);
for (int i = 0; i < queries.Length; i++)
AddDeleteQuery(queries[i], numDocsInRAM);
return TimeToFlushDeletes();
}
}
private void QueryToSpanQuery(Query query, ICollection <byte[]> payloads)
{
if (query is BooleanQuery)
{
BooleanClause[] queryClauses = ((BooleanQuery)query).GetClauses();
for (int i = 0; i < queryClauses.Length; i++)
{
if (!queryClauses[i].IsProhibited())
{
QueryToSpanQuery(queryClauses[i].GetQuery(), payloads);
}
}
}
else if (query is PhraseQuery)
{
Term[] phraseQueryTerms = ((PhraseQuery)query).GetTerms();
SpanQuery[] clauses = new SpanQuery[phraseQueryTerms.Length];
for (int i = 0; i < phraseQueryTerms.Length; i++)
{
clauses[i] = new SpanTermQuery(phraseQueryTerms[i]);
}
int slop = ((PhraseQuery)query).GetSlop();
bool inorder = false;
if (slop == 0)
{
inorder = true;
}
SpanNearQuery sp = new SpanNearQuery(clauses, slop, inorder);
sp.SetBoost(query.GetBoost());
GetPayloads(payloads, sp);
}
else if (query is TermQuery)
{
SpanTermQuery stq = new SpanTermQuery(((TermQuery)query).GetTerm());
stq.SetBoost(query.GetBoost());
GetPayloads(payloads, stq);
}
else if (query is SpanQuery)
{
GetPayloads(payloads, (SpanQuery)query);
}
else if (query is FilteredQuery)
{
QueryToSpanQuery(((FilteredQuery)query).GetQuery(), payloads);
}
else if (query is DisjunctionMaxQuery)
{
for (System.Collections.IEnumerator iterator = ((DisjunctionMaxQuery)query).Iterator(); iterator.MoveNext();)
{
QueryToSpanQuery((Query)iterator.Current, payloads);
}
}
else if (query is MultiPhraseQuery)
{
MultiPhraseQuery mpq = (MultiPhraseQuery)query;
System.Collections.IList termArrays = mpq.GetTermArrays();
int[] positions = mpq.GetPositions();
if (positions.Length > 0)
{
int maxPosition = positions[positions.Length - 1];
for (int i = 0; i < positions.Length - 1; ++i)
{
if (positions[i] > maxPosition)
{
maxPosition = positions[i];
}
}
System.Collections.ArrayList[] disjunctLists = new System.Collections.ArrayList[maxPosition + 1];
int distinctPositions = 0;
for (int i = 0; i < termArrays.Count; ++i)
{
Term[] termArray = (Term[])termArrays[i];
System.Collections.IList disjuncts = disjunctLists[positions[i]];
if (disjuncts == null)
{
disjuncts = (disjunctLists[positions[i]] = new System.Collections.ArrayList(termArray.Length));
++distinctPositions;
}
for (int j = 0; j < termArray.Length; ++j)
{
disjuncts.Add(new SpanTermQuery(termArray[j]));
}
}
int positionGaps = 0;
int position = 0;
SpanQuery[] clauses = new SpanQuery[distinctPositions];
for (int i = 0; i < disjunctLists.Length; ++i)
{
System.Collections.ArrayList disjuncts = disjunctLists[i];
if (disjuncts != null)
{
clauses[position++] = new SpanOrQuery((SpanQuery[])(disjuncts.ToArray(typeof(SpanQuery[]))));
}
else
{
++positionGaps;
}
}
int slop = mpq.GetSlop();
bool inorder = (slop == 0);
SpanNearQuery sp = new SpanNearQuery(clauses, slop + positionGaps, inorder);
sp.SetBoost(query.GetBoost());
GetPayloads(payloads, sp);
}
}
}
protected internal virtual void AddClause(System.Collections.IList clauses, int conj, int mods, Query q)
{
bool required, prohibited;
// If this term is introduced by AND, make the preceding term required,
// unless it's already prohibited
if (clauses.Count > 0 && conj == CONJ_AND)
{
BooleanClause c = (BooleanClause) clauses[clauses.Count - 1];
if (!c.IsProhibited())
c.SetOccur(BooleanClause.Occur.MUST);
}
if (clauses.Count > 0 && operator_Renamed == AND_OPERATOR && conj == CONJ_OR)
{
// If this term is introduced by OR, make the preceding term optional,
// unless it's prohibited (that means we leave -a OR b but +a OR b-->a OR b)
// notice if the input is a OR b, first term is parsed as required; without
// this modification a OR b would parsed as +a OR b
BooleanClause c = (BooleanClause) clauses[clauses.Count - 1];
if (!c.IsProhibited())
c.SetOccur(BooleanClause.Occur.SHOULD);
}
// We might have been passed a null query; the term might have been
// filtered away by the analyzer.
if (q == null)
return ;
if (operator_Renamed == OR_OPERATOR)
{
// We set REQUIRED if we're introduced by AND or +; PROHIBITED if
// introduced by NOT or -; make sure not to set both.
prohibited = (mods == MOD_NOT);
required = (mods == MOD_REQ);
if (conj == CONJ_AND && !prohibited)
{
required = true;
}
}
else
{
// We set PROHIBITED if we're introduced by NOT or -; We set REQUIRED
// if not PROHIBITED and not introduced by OR
prohibited = (mods == MOD_NOT);
required = (!prohibited && conj != CONJ_OR);
}
if (required && !prohibited)
clauses.Add(NewBooleanClause(q, BooleanClause.Occur.MUST));
else if (!required && !prohibited)
clauses.Add(NewBooleanClause(q, BooleanClause.Occur.SHOULD));
else if (!required && prohibited)
clauses.Add(NewBooleanClause(q, BooleanClause.Occur.MUST_NOT));
else
throw new System.SystemException("Clause cannot be both required and prohibited");
}
/// <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);
}
private bool strict = false; // if true, valueSource part of query does not take part in weights normalization.
/// <summary> Create a CustomScoreQuery over input subQuery.</summary>
/// <param name="subQuery">the sub query whose scored is being customed. Must not be null.
/// </param>
public CustomScoreQuery(Query subQuery) : this(subQuery, new ValueSourceQuery[0])
{
}
protected internal virtual void AddClause(System.Collections.ArrayList clauses, int conj, int mods, Query q)
{
AddClause((System.Collections.IList) clauses, conj, mods, q);
}
/// <summary> Query should be rewritten for wild/fuzzy support.
///
/// </summary>
/// <param name="query">
/// </param>
/// <returns> payloads Collection
/// </returns>
/// <throws> IOException </throws>
public virtual ICollection<byte[]> GetPayloadsForQuery(Query query)
{
ICollection<byte[]> payloads = new List<byte[]>();
QueryToSpanQuery(query, payloads);
return payloads;
}
private bool strict = false; // if true, valueSource part of query does not take part in weights normalization.
/// <summary> Create a CustomScoreQuery over input subQuery.</summary>
/// <param name="subQuery">the sub query whose scored is being customed. Must not be null.
/// </param>
public CustomScoreQuery(Query subQuery):this(subQuery, new ValueSourceQuery[0])
{
}
private void ApplySlop(Query q, int slop)
{
if (q is PhraseQuery)
{
((PhraseQuery) q).SetSlop(slop);
}
else if (q is MultiPhraseQuery)
{
((MultiPhraseQuery) q).SetSlop(slop);
}
}
private void AddDeleteQuery(Query query, int docID)
{
lock (this)
{
deletesInRAM.queries[query] = (System.Int32) (flushedDocCount + docID);
deletesInRAM.AddBytesUsed(BYTES_PER_DEL_QUERY);
}
}
internal bool BufferDeleteQuery(Query query)
{
lock (this)
{
WaitReady(null);
AddDeleteQuery(query, numDocsInRAM);
return TimeToFlushDeletes();
}
}
private void QueryToSpanQuery(Query query, ICollection<byte[]> payloads)
{
if (query is BooleanQuery)
{
BooleanClause[] queryClauses = ((BooleanQuery) query).GetClauses();
for (int i = 0; i < queryClauses.Length; i++)
{
if (!queryClauses[i].IsProhibited())
{
QueryToSpanQuery(queryClauses[i].GetQuery(), payloads);
}
}
}
else if (query is PhraseQuery)
{
Term[] phraseQueryTerms = ((PhraseQuery) query).GetTerms();
SpanQuery[] clauses = new SpanQuery[phraseQueryTerms.Length];
for (int i = 0; i < phraseQueryTerms.Length; i++)
{
clauses[i] = new SpanTermQuery(phraseQueryTerms[i]);
}
int slop = ((PhraseQuery) query).GetSlop();
bool inorder = false;
if (slop == 0)
{
inorder = true;
}
SpanNearQuery sp = new SpanNearQuery(clauses, slop, inorder);
sp.SetBoost(query.GetBoost());
GetPayloads(payloads, sp);
}
else if (query is TermQuery)
{
SpanTermQuery stq = new SpanTermQuery(((TermQuery) query).GetTerm());
stq.SetBoost(query.GetBoost());
GetPayloads(payloads, stq);
}
else if (query is SpanQuery)
{
GetPayloads(payloads, (SpanQuery) query);
}
else if (query is FilteredQuery)
{
QueryToSpanQuery(((FilteredQuery) query).GetQuery(), payloads);
}
else if (query is DisjunctionMaxQuery)
{
for (System.Collections.IEnumerator iterator = ((DisjunctionMaxQuery) query).Iterator(); iterator.MoveNext(); )
{
QueryToSpanQuery((Query) iterator.Current, payloads);
}
}
else if (query is MultiPhraseQuery)
{
MultiPhraseQuery mpq = (MultiPhraseQuery) query;
System.Collections.IList termArrays = mpq.GetTermArrays();
int[] positions = mpq.GetPositions();
if (positions.Length > 0)
{
int maxPosition = positions[positions.Length - 1];
for (int i = 0; i < positions.Length - 1; ++i)
{
if (positions[i] > maxPosition)
{
maxPosition = positions[i];
}
}
System.Collections.ArrayList[] disjunctLists = new System.Collections.ArrayList[maxPosition + 1];
int distinctPositions = 0;
for (int i = 0; i < termArrays.Count; ++i)
{
Term[] termArray = (Term[]) termArrays[i];
System.Collections.IList disjuncts = disjunctLists[positions[i]];
if (disjuncts == null)
{
disjuncts = (disjunctLists[positions[i]] = new System.Collections.ArrayList(termArray.Length));
++distinctPositions;
}
for (int j = 0; j < termArray.Length; ++j)
{
disjuncts.Add(new SpanTermQuery(termArray[j]));
}
}
int positionGaps = 0;
int position = 0;
SpanQuery[] clauses = new SpanQuery[distinctPositions];
for (int i = 0; i < disjunctLists.Length; ++i)
{
System.Collections.ArrayList disjuncts = disjunctLists[i];
if (disjuncts != null)
{
clauses[position++] = new SpanOrQuery((SpanQuery[]) (disjuncts.ToArray(typeof(SpanQuery[]))));
}
else
{
++positionGaps;
}
}
int slop = mpq.GetSlop();
bool inorder = (slop == 0);
SpanNearQuery sp = new SpanNearQuery(clauses, slop + positionGaps, inorder);
sp.SetBoost(query.GetBoost());
GetPayloads(payloads, sp);
}
}
}
/// <summary> Deletes the document(s) matching any of the provided queries.
/// All deletes are flushed at the same time.
///
/// <p/><b>NOTE</b>: if this method hits an OutOfMemoryError
/// you should immediately close the writer. See <a
/// href="#OOME">above</a> for details.<p/>
///
/// </summary>
/// <param name="queries">array of queries to identify the documents
/// to be deleted
/// </param>
/// <throws> CorruptIndexException if the index is corrupt </throws>
/// <throws> IOException if there is a low-level IO error </throws>
public virtual void DeleteDocuments(Query[] queries)
{
EnsureOpen();
bool doFlush = docWriter.BufferDeleteQueries(queries);
if (doFlush)
Flush(true, false, false);
}
