public TermWeight(TermQuery outerInstance, IndexSearcher searcher, TermContext termStates)
{
this.OuterInstance = outerInstance;
Debug.Assert(termStates != null, "TermContext must not be null");
this.TermStates = termStates;
this.Similarity = searcher.Similarity;
this.Stats = Similarity.ComputeWeight(outerInstance.Boost, searcher.CollectionStatistics(outerInstance.Term_Renamed.Field()), searcher.TermStatistics(outerInstance.Term_Renamed, termStates));
}
public override Query Rewrite(IndexReader reader)
{
if (this.m_terms.Count == 0)
{
return(new BooleanQuery());
}
else if (this.m_terms.Count == 1)
{
Query tq = NewTermQuery(this.m_terms[0], null);
tq.Boost = Boost;
return(tq);
}
var leaves = reader.Leaves;
int maxDoc = reader.MaxDoc;
var contextArray = new TermContext[m_terms.Count];
var queryTerms = this.m_terms.ToArray();
CollectTermContext(reader, leaves, contextArray, queryTerms);
return(BuildQuery(maxDoc, contextArray, queryTerms));
}
public MultiPhraseWeight(MultiPhraseQuery outerInstance, IndexSearcher searcher)
{
this.outerInstance = outerInstance;
this.similarity = searcher.Similarity;
IndexReaderContext context = searcher.TopReaderContext;
// compute idf
var allTermStats = new JCG.List <TermStatistics>();
foreach (Term[] terms in outerInstance.termArrays)
{
foreach (Term term in terms)
{
if (!termContexts.TryGetValue(term, out TermContext termContext) || termContext is null)
{
termContext = TermContext.Build(context, term);
termContexts[term] = termContext;
}
allTermStats.Add(searcher.TermStatistics(term, termContext));
}
}
stats = similarity.ComputeWeight(outerInstance.Boost, searcher.CollectionStatistics(outerInstance.field), allTermStats.ToArray());
}
public static void Initialize(IServiceProvider serviceProvider)
{
using (var context = new TermContext(serviceProvider.GetRequiredService <DbContextOptions <TermContext> >()))
{
// Look for any movies.
if (context.Term.Any())
{
return; // DB has been seeded
}
context.Term.AddRange(
new Term
{
TermID = 1,
Terms = "Physics",
Subject = "General Information",
Definitions = "Physics is the branch of science concerned with the nature and properties of matter and energy",
Questions = "What is Physics?",
Answers = "Physics is the branch of science concerned with the nature and properties of matter and energy"
}
);
context.SaveChanges();
}
}
// Mock: in a real env, this would hit the wire and get
// term stats from remote node
internal virtual IDictionary <Term, TermStatistics> GetNodeTermStats(ISet <Term> terms, int nodeID, long version)
{
NodeState node = m_nodes[nodeID];
IDictionary <Term, TermStatistics> stats = new Dictionary <Term, TermStatistics>();
IndexSearcher s = node.Searchers.Acquire(version);
if (s is null)
{
throw new SearcherExpiredException("node=" + nodeID + " version=" + version);
}
try
{
foreach (Term term in terms)
{
TermContext termContext = TermContext.Build(s.IndexReader.Context, term);
stats[term] = s.TermStatistics(term, termContext);
}
}
finally
{
node.Searchers.Release(s);
}
return(stats);
}
public override Weight CreateWeight(IndexSearcher searcher)
{
IndexReaderContext context = searcher.TopReaderContext;
TermContext termState;
if (perReaderTermState == null || perReaderTermState.TopReaderContext != context)
{
// make TermQuery single-pass if we don't have a PRTS or if the context differs!
termState = TermContext.Build(context, term);
}
else
{
// PRTS was pre-build for this IS
termState = this.perReaderTermState;
}
// we must not ignore the given docFreq - if set use the given value (lie)
if (docFreq != -1)
{
termState.DocFreq = docFreq;
}
return(new TermWeight(this, searcher, termState));
}
internal SlowMinShouldMatchScorer(BooleanWeight weight, AtomicReader reader, IndexSearcher searcher)
: base(weight)
{
this.dv = reader.GetSortedSetDocValues("dv");
this.maxDoc = reader.MaxDoc;
BooleanQuery bq = (BooleanQuery)weight.Query;
this.minNrShouldMatch = bq.MinimumNumberShouldMatch;
this.sims = new SimScorer[(int)dv.ValueCount];
foreach (BooleanClause clause in bq.GetClauses())
{
if (Debugging.AssertsEnabled)
{
Debugging.Assert(!clause.IsProhibited);
}
if (Debugging.AssertsEnabled)
{
Debugging.Assert(!clause.IsRequired);
}
Term term = ((TermQuery)clause.Query).Term;
long ord = dv.LookupTerm(term.Bytes);
if (ord >= 0)
{
bool success = ords.Add(ord);
if (Debugging.AssertsEnabled)
{
Debugging.Assert(success); // no dups
}
TermContext context = TermContext.Build(reader.Context, term);
SimWeight w = weight.Similarity.ComputeWeight(1f, searcher.CollectionStatistics("field"), searcher.TermStatistics(term, context));
var dummy = w.GetValueForNormalization(); // ignored
w.Normalize(1F, 1F);
sims[(int)ord] = weight.Similarity.GetSimScorer(w, (AtomicReaderContext)reader.Context);
}
}
}
public IdentifierContext(TermContext context) { CopyFrom(context); }
public FalseContext(TermContext context)
{
CopyFrom(context);
}
public IndexModel(TermContext context)
{
_context = context;
}
/// <summary>
/// Returns <see cref="Search.TermStatistics"/> for a term.
/// <para/>
/// This can be overridden for example, to return a term's statistics
/// across a distributed collection.
/// <para/>
/// @lucene.experimental
/// </summary>
public virtual TermStatistics TermStatistics(Term term, TermContext context)
{
return(new TermStatistics(term.Bytes, context.DocFreq, context.TotalTermFreq));
}
public ScoreTerm(IComparer <BytesRef> termComp, TermContext termState)
{
this.TermComp = termComp;
this.TermState = termState;
this.Bytes = new BytesRef();
}
/// <summary>
/// Expert: constructs a TermQuery that will use the
/// provided docFreq instead of looking up the docFreq
/// against the searcher.
/// </summary>
public TermQuery(Term t, TermContext states)
{
Debug.Assert(states != null);
Term_Renamed = t;
DocFreq = states.DocFreq;
PerReaderTermState = states;
}
public AcronymController(TermContext db)
{
_db = db;
}
public TermContext term() {
TermContext _localctx = new TermContext(Context, State);
EnterRule(_localctx, 122, RULE_term);
int _la;
try {
EnterOuterAlt(_localctx, 1);
{
State = 792; factor();
State = 805;
ErrorHandler.Sync(this);
_la = TokenStream.La(1);
while (((((_la - 46)) & ~0x3f) == 0 && ((1L << (_la - 46)) & ((1L << (STAR - 46)) | (1L << (DIV - 46)) | (1L << (MOD - 46)) | (1L << (IDIV - 46)) | (1L << (AT - 46)))) != 0)) {
{
State = 803;
switch (TokenStream.La(1)) {
case STAR:
{
State = 793; Match(STAR);
State = 794; factor();
}
break;
case DIV:
{
State = 795; Match(DIV);
State = 796; factor();
}
break;
case MOD:
{
State = 797; Match(MOD);
State = 798; factor();
}
break;
case IDIV:
{
State = 799; Match(IDIV);
State = 800; factor();
}
break;
case AT:
{
State = 801; Match(AT);
State = 802; factor();
}
break;
default:
throw new NoViableAltException(this);
}
}
State = 807;
ErrorHandler.Sync(this);
_la = TokenStream.La(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return _localctx;
}
public TermController(TermContext db)
{
_db = db;
}
public TermContext term() {
TermContext _localctx = new TermContext(Context, State);
EnterRule(_localctx, 0, RULE_term);
try {
State = 35;
switch ( Interpreter.AdaptivePredict(TokenStream,0,Context) ) {
case 1:
EnterOuterAlt(_localctx, 1);
{
State = 18; _localctx._INT = Match(INT);
_localctx.value = PumpingLemma.LinearIntegerExpression.Constant((_localctx._INT!=null?int.Parse(_localctx._INT.Text):0));
}
break;
case 2:
EnterOuterAlt(_localctx, 2);
{
State = 20; _localctx._IDENT = Match(IDENT);
_localctx.value = PumpingLemma.LinearIntegerExpression.Variable((_localctx._IDENT!=null?_localctx._IDENT.Text:null));
}
break;
case 3:
EnterOuterAlt(_localctx, 3);
{
State = 22; _localctx._INT = Match(INT);
State = 23; Match(TIMES);
State = 24; _localctx._IDENT = Match(IDENT);
_localctx.value = PumpingLemma.LinearIntegerExpression.SingleTerm(
(_localctx._INT!=null?int.Parse(_localctx._INT.Text):0),
PumpingLemma.VariableType.Variable((_localctx._IDENT!=null?_localctx._IDENT.Text:null))
);
}
break;
case 4:
EnterOuterAlt(_localctx, 4);
{
State = 26; _localctx._IDENT = Match(IDENT);
State = 27; Match(TIMES);
State = 28; _localctx._INT = Match(INT);
_localctx.value = PumpingLemma.LinearIntegerExpression.SingleTerm(
(_localctx._INT!=null?int.Parse(_localctx._INT.Text):0),
PumpingLemma.VariableType.Variable((_localctx._IDENT!=null?_localctx._IDENT.Text:null))
);
}
break;
case 5:
EnterOuterAlt(_localctx, 5);
{
State = 30; Match(LPAREN);
State = 31; _localctx.a = terms();
State = 32; Match(RPAREN);
_localctx.value = _localctx.a.value;
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return _localctx;
}
public TermContext term()
{
TermContext _localctx = new TermContext(Context, State);
EnterRule(_localctx, 4, RULE_term);
int _la;
try {
State = 42;
ErrorHandler.Sync(this);
switch (Interpreter.AdaptivePredict(TokenStream, 5, Context))
{
case 1:
EnterOuterAlt(_localctx, 1);
{
State = 26; Match(IDENTIFIER);
}
break;
case 2:
EnterOuterAlt(_localctx, 2);
{
State = 27; Match(INTEGER);
}
break;
case 3:
EnterOuterAlt(_localctx, 3);
{
State = 28; predicate_atom();
}
break;
case 4:
EnterOuterAlt(_localctx, 4);
{
State = 29; Match(T__3);
State = 38;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__3) | (1L << IDENTIFIER) | (1L << INTEGER) | (1L << STRING))) != 0))
{
{
State = 30; term();
State = 35;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
while (_la == T__1)
{
{
{
State = 31; Match(T__1);
State = 32; term();
}
}
State = 37;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
}
}
}
State = 40; Match(T__4);
}
break;
case 5:
EnterOuterAlt(_localctx, 5);
{
State = 41; Match(STRING);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
private TermContext term(int _p)
{
ParserRuleContext _parentctx = Context;
int _parentState = State;
TermContext _localctx = new TermContext(Context, _parentState);
TermContext _prevctx = _localctx;
int _startState = 6;
EnterRecursionRule(_localctx, 6, RULE_term, _p);
try {
int _alt;
EnterOuterAlt(_localctx, 1);
{
State = 53;
ErrorHandler.Sync(this);
switch (TokenStream.LA(1))
{
case T__1:
{
_localctx = new ParContext(_localctx);
Context = _localctx;
_prevctx = _localctx;
State = 25; Match(T__1);
State = 26; term(0);
State = 27; Match(T__2);
}
break;
case VAR:
{
_localctx = new VarContext(_localctx);
Context = _localctx;
_prevctx = _localctx;
State = 29; Match(VAR);
}
break;
case T__3:
{
_localctx = new IftContext(_localctx);
Context = _localctx;
_prevctx = _localctx;
State = 30; Match(T__3);
State = 31; term(0);
State = 32; Match(T__4);
State = 33; term(0);
State = 34; Match(T__5);
State = 35; term(5);
}
break;
case T__6:
{
_localctx = new TrueContext(_localctx);
Context = _localctx;
_prevctx = _localctx;
State = 37; Match(T__6);
}
break;
case T__7:
{
_localctx = new FalseContext(_localctx);
Context = _localctx;
_prevctx = _localctx;
State = 38; Match(T__7);
}
break;
case T__8:
{
_localctx = new LetContext(_localctx);
Context = _localctx;
_prevctx = _localctx;
State = 39; Match(T__8);
State = 40; Match(VAR);
State = 41; Match(T__9);
State = 42; term(0);
State = 43; Match(T__10);
State = 44; term(2);
}
break;
case LAMBDA:
{
_localctx = new AbsContext(_localctx);
Context = _localctx;
_prevctx = _localctx;
State = 46; Match(LAMBDA);
State = 47; Match(VAR);
State = 48; Match(T__11);
State = 49; type(0);
State = 50; Match(DOT);
State = 51; term(1);
}
break;
default:
throw new NoViableAltException(this);
}
Context.Stop = TokenStream.LT(-1);
State = 59;
ErrorHandler.Sync(this);
_alt = Interpreter.AdaptivePredict(TokenStream, 3, Context);
while (_alt != 2 && _alt != global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER)
{
if (_alt == 1)
{
if (ParseListeners != null)
{
TriggerExitRuleEvent();
}
_prevctx = _localctx;
{
{
_localctx = new AppContext(new TermContext(_parentctx, _parentState));
PushNewRecursionContext(_localctx, _startState, RULE_term);
State = 55;
if (!(Precpred(Context, 6)))
{
throw new FailedPredicateException(this, "Precpred(Context, 6)");
}
State = 56; term(7);
}
}
}
State = 61;
ErrorHandler.Sync(this);
_alt = Interpreter.AdaptivePredict(TokenStream, 3, Context);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
UnrollRecursionContexts(_parentctx);
}
return(_localctx);
}
public LetContext(TermContext context)
{
CopyFrom(context);
}
public ParenthesisContext(TermContext context) { CopyFrom(context); }
/// <summary>
/// Expert: constructs a TermQuery that will use the
/// provided docFreq instead of looking up the docFreq
/// against the searcher.
/// </summary>
public TermQuery(Term t, int docFreq)
{
Term_Renamed = t;
this.DocFreq = docFreq;
PerReaderTermState = null;
}
public TermContext term() {
TermContext _localctx = new TermContext(Context, State);
EnterRule(_localctx, 12, RULE_term);
try {
State = 77;
switch (TokenStream.La(1)) {
case ID:
_localctx = new IdentifierContext(_localctx);
EnterOuterAlt(_localctx, 1);
{
State = 70; Match(ID);
}
break;
case T__6:
_localctx = new NegationContext(_localctx);
EnterOuterAlt(_localctx, 2);
{
State = 71; Match(T__6);
State = 72; term();
}
break;
case T__7:
_localctx = new ParenthesisContext(_localctx);
EnterOuterAlt(_localctx, 3);
{
State = 73; Match(T__7);
State = 74; expression();
State = 75; Match(T__8);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return _localctx;
}
public NegationContext(TermContext context) { CopyFrom(context); }
public CreateModel(TermContext context)
{
_context = context;
}
public DetailsModel(TermContext context)
{
_context = context;
}
protected internal override void AddClause(SpanOrQuery topLevel, Term term, int docFreq, float boost, TermContext states)
{
SpanTermQuery q = new SpanTermQuery(term);
q.Boost = boost;
topLevel.AddClause(q);
}
protected override void AddClause(BooleanQuery topLevel, Term term, int docFreq, float boost, TermContext states) //ignored
{
topLevel.Add(new TermQuery(term, states), Occur.SHOULD);
}
public EditModel(TermContext context)
{
_context = context;
}
/// <summary>
/// Expert: constructs a <see cref="TermQuery"/> that will use the
/// provided <paramref name="docFreq"/> instead of looking up the docFreq
/// against the searcher.
/// </summary>
public TermQuery(Term t, int docFreq)
{
term = t;
this.docFreq = docFreq;
perReaderTermState = null;
}
protected override void AddClause(BooleanQuery topLevel, Term term, int docCount, float boost, TermContext states)
{
TermQuery tq = new TermQuery(term, states);
tq.Boost = boost;
topLevel.Add(tq, Occur.SHOULD);
}
public TermContext term()
{
TermContext _localctx = new TermContext(Context, State);
EnterRule(_localctx, 12, RULE_term);
int _la;
try {
State = 114;
ErrorHandler.Sync(this);
switch (Interpreter.AdaptivePredict(TokenStream, 13, Context))
{
case 1:
EnterOuterAlt(_localctx, 1);
{
State = 98; Match(IDENTIFIER);
}
break;
case 2:
EnterOuterAlt(_localctx, 2);
{
State = 99; Match(INTEGER_CONSTANT);
}
break;
case 3:
EnterOuterAlt(_localctx, 3);
{
State = 100; predicate();
}
break;
case 4:
EnterOuterAlt(_localctx, 4);
{
State = 101; Match(OPEN_SQUARE_BRACKET);
State = 110;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << OPEN_SQUARE_BRACKET) | (1L << IDENTIFIER) | (1L << INTEGER_CONSTANT) | (1L << STRING_CONSTANT))) != 0))
{
{
State = 102; term();
State = 107;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
while (_la == COMMA)
{
{
{
State = 103; Match(COMMA);
State = 104; term();
}
}
State = 109;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
}
}
}
State = 112; Match(CLOSE_SQUARE_BRACKET);
}
break;
case 5:
EnterOuterAlt(_localctx, 5);
{
State = 113; Match(STRING_CONSTANT);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
public override TermStatistics TermStatistics(Term term, TermContext context)
{
Debug.Assert(term != null);
long docFreq = 0;
long totalTermFreq = 0;
for (int nodeID = 0; nodeID < NodeVersions.Length; nodeID++)
{
TermStatistics subStats;
if (nodeID == MyNodeID)
{
subStats = base.TermStatistics(term, context);
}
else
{
TermAndShardVersion key = new TermAndShardVersion(nodeID, NodeVersions[nodeID], term);
subStats = OuterInstance.TermStatsCache[key];
// We pre-cached during rewrite so all terms
// better be here...
Debug.Assert(subStats != null);
}
long nodeDocFreq = subStats.DocFreq();
if (docFreq >= 0 && nodeDocFreq >= 0)
{
docFreq += nodeDocFreq;
}
else
{
docFreq = -1;
}
long nodeTotalTermFreq = subStats.TotalTermFreq();
if (totalTermFreq >= 0 && nodeTotalTermFreq >= 0)
{
totalTermFreq += nodeTotalTermFreq;
}
else
{
totalTermFreq = -1;
}
}
return new TermStatistics(term.Bytes(), docFreq, totalTermFreq);
}
protected internal override void AddClause(SpanOrQuery topLevel, Term term, int docCount, float boost, TermContext states)
{
// TODO: would be nice to not lose term-state here.
// we could add a hack option to SpanOrQuery, but the hack would only work if this is the top-level Span
// (if you put this thing in another span query, it would extractTerms/double-seek anyway)
SpanTermQuery q = new SpanTermQuery(term);
q.Boost = boost;
topLevel.AddClause(q);
}
protected internal virtual Query BuildQuery(int maxDoc, TermContext[] contextArray, Term[] queryTerms)
{
var lowFreq = new BooleanQuery(disableCoord);
var highFreq = new BooleanQuery(disableCoord)
{
Boost = highFreqBoost
};
lowFreq.Boost = lowFreqBoost;
var query = new BooleanQuery(true);
for (int i = 0; i < queryTerms.Length; i++)
{
TermContext termContext = contextArray[i];
if (termContext == null)
{
lowFreq.Add(NewTermQuery(queryTerms[i], null), lowFreqOccur);
}
else
{
if ((maxTermFrequency >= 1f && termContext.DocFreq > maxTermFrequency) || (termContext.DocFreq > (int)Math.Ceiling(maxTermFrequency * (float)maxDoc)))
{
highFreq.Add(NewTermQuery(queryTerms[i], termContext), highFreqOccur);
}
else
{
lowFreq.Add(NewTermQuery(queryTerms[i], termContext), lowFreqOccur);
}
}
}
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int numLowFreqClauses = lowFreq.clauses().size();
int numLowFreqClauses = lowFreq.Clauses.Length;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int numHighFreqClauses = highFreq.clauses().size();
int numHighFreqClauses = highFreq.Clauses.Length;
if (lowFreqOccur == BooleanClause.Occur.SHOULD && numLowFreqClauses > 0)
{
int minMustMatch = CalcLowFreqMinimumNumberShouldMatch(numLowFreqClauses);
lowFreq.MinimumNumberShouldMatch = minMustMatch;
}
if (highFreqOccur == BooleanClause.Occur.SHOULD && numHighFreqClauses > 0)
{
int minMustMatch = CalcHighFreqMinimumNumberShouldMatch(numHighFreqClauses);
highFreq.MinimumNumberShouldMatch = minMustMatch;
}
if (lowFreq.Clauses.Length == 0)
{
/*
* if lowFreq is empty we rewrite the high freq terms in a conjunction to
* prevent slow queries.
*/
if (highFreq.MinimumNumberShouldMatch == 0 && highFreqOccur != BooleanClause.Occur.MUST)
{
foreach (BooleanClause booleanClause in highFreq)
{
booleanClause.Occur_ = BooleanClause.Occur.MUST;
}
}
highFreq.Boost = Boost;
return(highFreq);
}
else if (highFreq.Clauses.Length == 0)
{
// only do low freq terms - we don't have high freq terms
lowFreq.Boost = Boost;
return(lowFreq);
}
else
{
query.Add(highFreq, BooleanClause.Occur.SHOULD);
query.Add(lowFreq, BooleanClause.Occur.MUST);
query.Boost = Boost;
return(query);
}
}
/// <summary>
/// Fills a <see cref="T:IDictionary{string, WeightedSpanTerm}"/> with <see cref="WeightedSpanTerm"/>s using the terms from the supplied <see cref="SpanQuery"/>.
/// </summary>
/// <param name="terms"><see cref="T:IDictionary{string, WeightedSpanTerm}"/> to place created <see cref="WeightedSpanTerm"/>s in</param>
/// <param name="spanQuery"><see cref="SpanQuery"/> to extract Terms from</param>
/// <exception cref="IOException">If there is a low-level I/O error</exception>
protected virtual void ExtractWeightedSpanTerms(IDictionary <string, WeightedSpanTerm> terms, SpanQuery spanQuery)
{
ISet <string> fieldNames;
if (fieldName == null)
{
fieldNames = new JCG.HashSet <string>();
CollectSpanQueryFields(spanQuery, fieldNames);
}
else
{
fieldNames = new JCG.HashSet <string>
{
fieldName
};
}
// To support the use of the default field name
if (defaultField != null)
{
fieldNames.Add(defaultField);
}
IDictionary <string, SpanQuery> queries = new JCG.Dictionary <string, SpanQuery>();
var nonWeightedTerms = new JCG.HashSet <Term>();
bool mustRewriteQuery = MustRewriteQuery(spanQuery);
if (mustRewriteQuery)
{
foreach (string field in fieldNames)
{
SpanQuery rewrittenQuery = (SpanQuery)spanQuery.Rewrite(GetLeafContext().Reader);
queries[field] = rewrittenQuery;
rewrittenQuery.ExtractTerms(nonWeightedTerms);
}
}
else
{
spanQuery.ExtractTerms(nonWeightedTerms);
}
List <PositionSpan> spanPositions = new List <PositionSpan>();
foreach (string field in fieldNames)
{
SpanQuery q;
q = mustRewriteQuery ? queries[field] : spanQuery;
AtomicReaderContext context = GetLeafContext();
var termContexts = new JCG.Dictionary <Term, TermContext>();
ISet <Term> extractedTerms = new JCG.SortedSet <Term>();
q.ExtractTerms(extractedTerms);
foreach (Term term in extractedTerms)
{
termContexts[term] = TermContext.Build(context, term);
}
IBits acceptDocs = context.AtomicReader.LiveDocs;
Spans.Spans spans = q.GetSpans(context, acceptDocs, termContexts);
// collect span positions
while (spans.MoveNext())
{
spanPositions.Add(new PositionSpan(spans.Start, spans.End - 1));
}
}
if (spanPositions.Count == 0)
{
// no spans found
return;
}
foreach (Term queryTerm in nonWeightedTerms)
{
if (FieldNameComparer(queryTerm.Field))
{
if (!terms.TryGetValue(queryTerm.Text, out WeightedSpanTerm weightedSpanTerm) || weightedSpanTerm == null)
{
weightedSpanTerm = new WeightedSpanTerm(spanQuery.Boost, queryTerm.Text);
weightedSpanTerm.AddPositionSpans(spanPositions);
weightedSpanTerm.IsPositionSensitive = true;
terms[queryTerm.Text] = weightedSpanTerm;
}
else
{
if (spanPositions.Count > 0)
{
weightedSpanTerm.AddPositionSpans(spanPositions);
}
}
}
}
}
protected virtual Query BuildQuery(int maxDoc, TermContext[] contextArray, Term[] queryTerms)
{
var lowFreq = new BooleanQuery(m_disableCoord);
var highFreq = new BooleanQuery(m_disableCoord)
{
Boost = m_highFreqBoost
};
lowFreq.Boost = m_lowFreqBoost;
var query = new BooleanQuery(true);
for (int i = 0; i < queryTerms.Length; i++)
{
TermContext termContext = contextArray[i];
if (termContext == null)
{
lowFreq.Add(NewTermQuery(queryTerms[i], null), m_lowFreqOccur);
}
else
{
if ((m_maxTermFrequency >= 1f && termContext.DocFreq > m_maxTermFrequency) || (termContext.DocFreq > (int)Math.Ceiling(m_maxTermFrequency * (float)maxDoc)))
{
highFreq.Add(NewTermQuery(queryTerms[i], termContext), m_highFreqOccur);
}
else
{
lowFreq.Add(NewTermQuery(queryTerms[i], termContext), m_lowFreqOccur);
}
}
}
int numLowFreqClauses = lowFreq.GetClauses().Length;
int numHighFreqClauses = highFreq.GetClauses().Length;
if (m_lowFreqOccur == Occur.SHOULD && numLowFreqClauses > 0)
{
int minMustMatch = CalcLowFreqMinimumNumberShouldMatch(numLowFreqClauses);
lowFreq.MinimumNumberShouldMatch = minMustMatch;
}
if (m_highFreqOccur == Occur.SHOULD && numHighFreqClauses > 0)
{
int minMustMatch = CalcHighFreqMinimumNumberShouldMatch(numHighFreqClauses);
highFreq.MinimumNumberShouldMatch = minMustMatch;
}
if (lowFreq.GetClauses().Length == 0)
{
/*
* if lowFreq is empty we rewrite the high freq terms in a conjunction to
* prevent slow queries.
*/
if (highFreq.MinimumNumberShouldMatch == 0 && m_highFreqOccur != Occur.MUST)
{
foreach (BooleanClause booleanClause in highFreq)
{
booleanClause.Occur = Occur.MUST;
}
}
highFreq.Boost = Boost;
return(highFreq);
}
else if (highFreq.GetClauses().Length == 0)
{
// only do low freq terms - we don't have high freq terms
lowFreq.Boost = Boost;
return(lowFreq);
}
else
{
query.Add(highFreq, Occur.SHOULD);
query.Add(lowFreq, Occur.MUST);
query.Boost = Boost;
return(query);
}
}
protected abstract void AddClause(Q topLevel, Term term, int docCount, float boost, TermContext states);
/// <summary>
/// Builds a new <see cref="TermQuery"/> instance.
/// <para>This is intended for subclasses that wish to customize the generated queries.</para> </summary>
/// <param name="term"> term </param>
/// <param name="context"> the <see cref="TermContext"/> to be used to create the low level term query. Can be <c>null</c>. </param>
/// <returns> new <see cref="TermQuery"/> instance </returns>
protected virtual Query NewTermQuery(Term term, TermContext context)
{
return(context == null ? new TermQuery(term) : new TermQuery(term, context));
}
protected override void AddClause(BooleanQuery topLevel, Term term, int docFreq, float boost, TermContext states)
{
Query q = new ConstantScoreQuery(new TermQuery(term, states));
q.Boost = boost;
topLevel.Add(q, Occur.SHOULD);
}
public virtual void CopyFrom(TermContext context) {
base.CopyFrom(context);
}
