private MultiSpansWrapper(IList<AtomicReaderContext> leaves, SpanQuery query, IDictionary<Term, TermContext> termContexts) { this.Query = query; this.Leaves = leaves; this.NumLeaves = leaves.Count; this.TermContexts = termContexts; }
private static void VisitQuery(SpanQuery query, AzureQueryLogger.IndentedTextWriter writer) { writer.WriteLine("Field: {0}", (object)query.Field); if (query is FieldMaskingSpanQuery) AzureQueryLogger.VisitQuery((FieldMaskingSpanQuery)query, writer); if (query is SpanFirstQuery) AzureQueryLogger.VisitQuery((SpanFirstQuery)query, writer); if (query is SpanNearQuery) AzureQueryLogger.VisitQuery((SpanNearQuery)query, writer); if (query is SpanNotQuery) AzureQueryLogger.VisitQuery((SpanNotQuery)query, writer); if (query is SpanOrQuery) AzureQueryLogger.VisitQuery((SpanOrQuery)query, writer); if (query is SpanRegexQuery) AzureQueryLogger.VisitQuery((SpanRegexQuery)query, writer); if (query is SpanTermQuery) AzureQueryLogger.VisitQuery((SpanTermQuery)query, writer); if (query is PayloadNearQuery) AzureQueryLogger.VisitQuery((PayloadNearQuery)query, writer); if (query is PayloadTermQuery) AzureQueryLogger.VisitQuery((PayloadTermQuery)query, writer); if (query is SpanWildcardQuery) AzureQueryLogger.VisitQuery((SpanWildcardQuery)query, writer); if (query is SpanLastQuery) AzureQueryLogger.VisitQuery((SpanLastQuery)query, writer); if (!(query is SpanFuzzyQuery)) return; AzureQueryLogger.VisitQuery((SpanFuzzyQuery)query, writer); }
/// <summary>Construct a SpanNotQuery matching spans from <c>include</c> which /// have no overlap with spans from <c>exclude</c>. /// </summary> public SpanNotQuery(SpanQuery include, SpanQuery exclude) { this.include = include; this.exclude = exclude; if (!include.GetField().Equals(exclude.GetField())) throw new System.ArgumentException("Clauses must have same field."); }
public SpanWeight(SpanQuery query, Searcher searcher) { this.similarity = query.GetSimilarity(searcher); this.query = query; this.terms = query.GetTerms(); idf = this.query.GetSimilarity(searcher).Idf(terms, searcher); }
public SpanWeight(SpanQuery query, Searcher searcher) { this.similarity = query.GetSimilarity(searcher); this.query = query; terms = new System.Collections.Hashtable(); query.ExtractTerms(terms); idfExp = similarity.idfExplain(new System.Collections.ArrayList(terms.Values), searcher); idf = idfExp.GetIdf(); }
public SpanWeight(SpanQuery query, Searcher searcher) { this.similarity = query.GetSimilarity(searcher); this.query = query; terms = new Support.Set<Lucene.Net.Index.Term>(); query.ExtractTerms(terms); idfExp = similarity.idfExplain(terms.ToArray(), searcher); idf = idfExp.GetIdf(); }
public virtual void TestSpanNearInOrderVersusOutOfOrder() { Term t1 = RandomTerm(); Term t2 = RandomTerm(); SpanQuery[] subquery = new SpanQuery[] { new SpanTermQuery(t1), new SpanTermQuery(t2) }; SpanNearQuery q1 = new SpanNearQuery(subquery, 3, true); SpanNearQuery q2 = new SpanNearQuery(subquery, 3, false); AssertSubsetOf(q1, q2); }
/// /// <param name="match"> The underlying <seealso cref="Lucene.Net.Search.Spans.SpanQuery"/> to check </param> /// <param name="payloadToMatch"> The <seealso cref="java.util.Collection"/> of payloads to match </param> public SpanPayloadCheckQuery(SpanQuery match, ICollection<byte[]> payloadToMatch) : base(match) { if (match is SpanNearQuery) { throw new System.ArgumentException("SpanNearQuery not allowed"); } this.PayloadToMatch = payloadToMatch; }
public SpanWeight(SpanQuery query, Searcher searcher) { this.similarity = query.GetSimilarity(searcher); this.internalQuery = query; terms = Lucene.Net.Support.Compatibility.SetFactory.CreateHashSet<Term>(); query.ExtractTerms(terms); idfExp = similarity.IdfExplain(terms, searcher); idf = idfExp.Idf; }
public virtual void TestSpanNearVersusPhrase() { Term t1 = RandomTerm(); Term t2 = RandomTerm(); SpanQuery[] subquery = new SpanQuery[] { new SpanTermQuery(t1), new SpanTermQuery(t2) }; SpanNearQuery q1 = new SpanNearQuery(subquery, 0, true); PhraseQuery q2 = new PhraseQuery(); q2.Add(t1); q2.Add(t2); AssertSameSet(q1, q2); }
public virtual void TestSpanNearVersusBooleanAnd() { Term t1 = RandomTerm(); Term t2 = RandomTerm(); SpanQuery[] subquery = new SpanQuery[] { new SpanTermQuery(t1), new SpanTermQuery(t2) }; SpanNearQuery q1 = new SpanNearQuery(subquery, int.MaxValue, false); BooleanQuery q2 = new BooleanQuery(); q2.Add(new TermQuery(t1), Occur.MUST); q2.Add(new TermQuery(t2), Occur.MUST); AssertSameSet(q1, q2); }
public SpanWeight(SpanQuery query, Searcher searcher) { this.similarity = query.GetSimilarity(searcher); this.query = query; terms = new System.Collections.Hashtable(); query.ExtractTerms(terms); System.Collections.ArrayList tmp = new System.Collections.ArrayList(terms.Values); idf = this.query.GetSimilarity(searcher).Idf(tmp, searcher); }
/// <summary> /// Construct a SpanNotQuery matching spans from <code>include</code> which /// have no overlap with spans from <code>exclude</code> within /// <code>pre</code> tokens before or <code>post</code> tokens of <code>include</code>. /// </summary> public SpanNotQuery(SpanQuery include, SpanQuery exclude, int pre, int post) { this.include = include; this.exclude = exclude; this.Pre = (pre >= 0) ? pre : 0; this.Post = (post >= 0) ? post : 0; if (include.Field != null && exclude.Field != null && !include.Field.Equals(exclude.Field)) { throw new System.ArgumentException("Clauses must have same field."); } }
public override System.Object Clone() { int sz = clauses.Count; SpanQuery[] newClauses = new SpanQuery[sz]; for (int i = 0; i < sz; i++) { SpanQuery clause = (SpanQuery) clauses[i]; newClauses[i] = (SpanQuery) clause.Clone(); } SpanOrQuery soq = new SpanOrQuery(newClauses); soq.SetBoost(GetBoost()); return soq; }
public static Spans Wrap(IndexReaderContext topLevelReaderContext, SpanQuery query) { IDictionary<Term, TermContext> termContexts = new Dictionary<Term, TermContext>(); SortedSet<Term> terms = new SortedSet<Term>(); query.ExtractTerms(terms); foreach (Term term in terms) { termContexts[term] = TermContext.Build(topLevelReaderContext, term); } IList<AtomicReaderContext> leaves = topLevelReaderContext.Leaves(); if (leaves.Count == 1) { AtomicReaderContext ctx = leaves[0]; return query.GetSpans(ctx, ((AtomicReader)ctx.Reader()).LiveDocs, termContexts); } return new MultiSpansWrapper(leaves, query, termContexts); }
public virtual Query Build(IQueryNode node) { // validates node BooleanQueryNode booleanNode = (BooleanQueryNode)node; IList<IQueryNode> children = booleanNode.GetChildren(); SpanQuery[] spanQueries = new SpanQuery[children.size()]; int i = 0; foreach (IQueryNode child in children) { spanQueries[i++] = (SpanQuery)child .GetTag(QueryTreeBuilder.QUERY_TREE_BUILDER_TAGID); } return new SpanOrQuery(spanQueries); }
/// <summary>Construct a SpanOrQuery merging the provided clauses. </summary> public SpanOrQuery(SpanQuery[] clauses) { // copy clauses array into an ArrayList this.clauses = new System.Collections.ArrayList(clauses.Length); for (int i = 0; i < clauses.Length; i++) { SpanQuery clause = clauses[i]; if (i == 0) { // check field field = clause.GetField(); } else if (!clause.GetField().Equals(field)) { throw new System.ArgumentException("Clauses must have same field."); } this.clauses.Add(clause); } }
public SpanNearQuery(SpanQuery[] clauses, int slop, bool inOrder, bool collectPayloads) { // copy clauses array into an ArrayList this.clauses = new List<SpanQuery>(clauses.Length); for (int i = 0; i < clauses.Length; i++) { SpanQuery clause = clauses[i]; if (field == null) // check field { field = clause.Field; } else if (clause.Field != null && !clause.Field.Equals(field)) { throw new System.ArgumentException("Clauses must have same field."); } this.clauses.Add(clause); } this.CollectPayloads = collectPayloads; this.slop = slop; this.inOrder = inOrder; }
public SpanWeight(SpanQuery query, IndexSearcher searcher) { this.Similarity = searcher.Similarity; this.query = query; TermContexts = new Dictionary<Term, TermContext>(); SortedSet<Term> terms = new SortedSet<Term>(); query.ExtractTerms(terms); IndexReaderContext context = searcher.TopReaderContext; TermStatistics[] termStats = new TermStatistics[terms.Count]; int i = 0; foreach (Term term in terms) { TermContext state = TermContext.Build(context, term); termStats[i] = searcher.TermStatistics(term, state); TermContexts[term] = state; i++; } string field = query.Field; if (field != null) { Stats = Similarity.ComputeWeight(query.Boost, searcher.CollectionStatistics(query.Field), termStats); } }
/// <summary> /// Construct a <see cref="SpanNotQuery"/> matching spans from <paramref name="include"/> which /// have no overlap with spans from <paramref name="exclude"/>. /// </summary> public SpanNotQuery(SpanQuery include, SpanQuery exclude) : this(include, exclude, 0, 0) { }
public SpanLastQuery(SpanQuery match, Analyzer analyzer) { this.match = match; this.analyzer = analyzer; }
public SpanLastQuery(SpanQuery match, int end) : this(match, (Analyzer)new StandardAnalyzer(global::Lucene.Net.Util.Version.LUCENE_30)) { }
/// <summary>Construct a SpanFirstQuery matching spans in <code>match</code> whose end /// position is less than or equal to <code>end</code>. /// </summary> public SpanFirstQuery(SpanQuery match, int end) { this.match = match; this.end = end; }
private Spans OrSpans(string[] terms) { SpanQuery[] sqa = new SpanQuery[terms.Length]; for (int i = 0; i < terms.Length; i++) { sqa[i] = MakeSpanTermQuery(terms[i]); } return MultiSpansWrapper.Wrap(Searcher.TopReaderContext, new SpanOrQuery(sqa)); }
private void OrderedSlopTest3SQ(SpanQuery q1, SpanQuery q2, SpanQuery q3, int slop, int[] expectedDocs) { bool ordered = true; SpanNearQuery snq = new SpanNearQuery(new SpanQuery[] { q1, q2, q3 }, slop, ordered); CheckHits(snq, expectedDocs); }
// LUCENE-1404 private SpanQuery CreateSpan(int slop, bool ordered, SpanQuery[] clauses) { return new SpanNearQuery(clauses, slop, ordered); }
private Spans OrSpans(System.String[] terms) { SpanQuery[] sqa = new SpanQuery[terms.Length]; for (int i = 0; i < terms.Length; i++) { sqa[i] = MakeSpanTermQuery(terms[i]); } return (new SpanOrQuery(sqa)).GetSpans(searcher.GetIndexReader()); }
public FieldMaskingSpanQuery(SpanQuery maskedQuery, string maskedField) { this.maskedQuery = maskedQuery; this.field = maskedField; }
/// <summary>Construct a SpanNearQuery. Matches spans matching a span from each /// clause, with up to <code>slop</code> total unmatched positions between /// them. * When <code>inOrder</code> is true, the spans from each clause /// must be * ordered as in <code>clauses</code>. /// </summary> public SpanNearQuery(SpanQuery[] clauses, int slop, bool inOrder):this(clauses, slop, inOrder, true) { }
public override System.Object Clone() { int sz = clauses.Count; SpanQuery[] newClauses = new SpanQuery[sz]; for (int i = 0; i < sz; i++) { SpanQuery clause = (SpanQuery) clauses[i]; newClauses[i] = (SpanQuery) clause.Clone(); } SpanNearQuery spanNearQuery = new SpanNearQuery(newClauses, slop, inOrder); spanNearQuery.SetBoost(GetBoost()); return spanNearQuery; }
protected internal virtual void Check(SpanQuery q, int[] docs) { CheckHits.CheckHitCollector(Random(), q, null, Searcher, docs); }
/// <summary>MACRO for SpanNearQuery containing three SpanQueries </summary> public virtual SpanNearQuery Snear(SpanQuery s, SpanQuery m, SpanQuery e, int slop, bool inOrder) { return new SpanNearQuery(new SpanQuery[]{s, m, e}, slop, inOrder); }
/// <summary> /// Construct a <see cref="SpanNotQuery"/> matching spans from <paramref name="include"/> which /// have no overlap with spans from <paramref name="exclude"/> within /// <paramref name="dist"/> tokens of <paramref name="include"/>. /// </summary> public SpanNotQuery(SpanQuery include, SpanQuery exclude, int dist) : this(include, exclude, dist, dist) { }