/// <summary> /// (non-Javadoc) /// @see org.apache.lucene.xmlparser.QueryObjectBuilder#process(org.w3c.dom.Element) /// </summary> public virtual Query GetQuery(XmlElement e) { XmlElement filterElement = DOMUtils.GetChildByTagOrFail(e, "Filter"); filterElement = DOMUtils.GetFirstChildOrFail(filterElement); Filter f = filterFactory.GetFilter(filterElement); XmlElement queryElement = DOMUtils.GetChildByTagOrFail(e, "Query"); queryElement = DOMUtils.GetFirstChildOrFail(queryElement); Query q = queryFactory.GetQuery(queryElement); FilteredQuery fq = new FilteredQuery(q, f); fq.Boost = DOMUtils.GetAttribute(e, "boost", 1.0f); return(fq); }
public void When_adding_filter_to_a_delete_statement() { var query = FilteredQuery.Make(_table); query.AddClause <Person, string>(p => p.Name, Operator.Equal, "Foo", Formatter.AndClauseSeparator); query.Parameters.Count.ShouldBe(1); query.Parameters["Name1"].ShouldBe("Foo"); var sql = query.Compile( Table.MakeOrGet <Person>(GenericSQLDialect.Instance, string.Empty).Delete); sql.ShouldBe(@"DELETE FROM [Person] WHERE 1 = 1 AND ([Name]=@Name1);"); }
public void When_creating_a_filtered_query() { var queryOne = FilteredQuery.Make(_table); queryOne.ShouldNotBeNull(); queryOne.Parameters.ShouldBeEmpty(); var sql = queryOne.Compile(); sql.ShouldBe(@"SELECT [Person].[Id] AS 'Id', [Person].[Name] AS 'Name', [Person].[Age] AS 'Age' FROM [Person] WHERE 1 = 1;"); }
private Query CreateQuery() { CreatePendingClause(); var booleanQuery = new BooleanQuery(); Query resultQuery = booleanQuery; if (_clauses.Count == 0) { if (_filters.Count > 0) // only filters applieds => transform to a boolean query { foreach (var clause in _filters) { booleanQuery.Add(clause); } resultQuery = booleanQuery; } else // search all documents, without filter or clause { resultQuery = new MatchAllDocsQuery(null); } } else { foreach (var clause in _clauses) { booleanQuery.Add(clause); } if (_filters.Count > 0) { var filter = new BooleanQuery(); foreach (var clause in _filters) { filter.Add(clause); } var queryFilter = new QueryWrapperFilter(filter); resultQuery = new FilteredQuery(booleanQuery, queryFilter); } } Logger.Debug("New search query: {0}", resultQuery.ToString()); return(resultQuery); }
private Query CreateQuery() { CreatePendingClause(); var booleanQuery = new BooleanQuery(); Query resultQuery = booleanQuery; if (_clauses.Count == 0) { if (_filters.Count > 0) { // only filters applied => transform to a boolean query foreach (var clause in _filters) { booleanQuery.Add(clause); } resultQuery = booleanQuery; } else { // search all documents, without filter or clause resultQuery = new MatchAllDocsQuery(); } } else { foreach (var clause in _clauses) { booleanQuery.Add(clause); } if (_filters.Count > 0) { var filter = new BooleanQuery(); foreach (var clause in _filters) { filter.Add(clause); } resultQuery = new FilteredQuery(booleanQuery, new QueryWrapperFilter(filter)); } } return(resultQuery); }
private static TopDocs DoSearch(IndexSearcher searcher, ScoreDoc after, Query q, Filter filter, int n, Sort sort, bool doDocScores, bool doMaxScore, Collector fc) { if (filter != null) { q = new FilteredQuery(q, filter); } int limit = searcher.IndexReader.MaxDoc; if (limit == 0) { limit = 1; } n = Math.Min(n, limit); if (after != null && after.Doc >= limit) { throw new System.ArgumentException("after.doc exceeds the number of documents in the reader: after.doc=" + after.Doc + " limit=" + limit); } if (sort != null) { if (after != null && !(after is FieldDoc)) { // TODO: if we fix type safety of TopFieldDocs we can // remove this throw new System.ArgumentException("after must be a FieldDoc; got " + after); } const bool fillFields = true; var hitsCollector = TopFieldCollector.Create(sort, n, (FieldDoc)after, fillFields, doDocScores, doMaxScore, false); searcher.Search(q, MultiCollector.Wrap(hitsCollector, fc)); return(hitsCollector.TopDocs()); } else { // TODO: can we pass the right boolean for // in-order instead of hardwired to false...? we'd // need access to the protected IS.search methods // taking Weight... could use reflection... var hitsCollector = TopScoreDocCollector.Create(n, after, false); searcher.Search(q, MultiCollector.Wrap(hitsCollector, fc)); return(hitsCollector.TopDocs()); } }
private static void Call(MethodCallExpression node, FilteredQuery query) { QueryParser.InternalParse(node.Arguments[0], query); Log.WriteLine(string.Format(" -> Call : {0}", node.Method.Name)); switch (node.Method.Name) { case "Where": ParseFilter(node.Arguments[1], query); break; case "Query": ParseQuery(node.Arguments[1], query); break; default: throw new Exception(string.Format("method not supported : {0}", node.Method.Name)); } }
public void When_adding_equality_clause() { var query = FilteredQuery.Make(_table); query.AddClause <Person, long>(p => p.Id, Operator.Equal, 1, Formatter.AndClauseSeparator); query.Parameters.Count.ShouldBe(1); query.Parameters["Id1"].ShouldBe(1); var sql = query.Compile(); sql.ShouldBe(@"SELECT [Person].[Id] AS 'Id', [Person].[Name] AS 'Name', [Person].[Age] AS 'Age' FROM [Person] WHERE 1 = 1 AND ([Id]=@Id1);"); }
public static int DistinctSearch(IndexBase index, SearchNode node, XElement root) { try { var query = MultiFieldQueryParser.Parse(Lucene.Net.Util.Version.LUCENE_29, node.Queries, node.Fields, node.Occurs, new PanGuAnalyzer(true)); foreach (ContainFilterNode cf in node.ContainFilters) { query = new FilteredQuery(query, new ContainFilter(new Term(cf.FieldName, cf.Text))); } return(ResponseDistinctSearch(index, query, node, root)); } catch (Lucene.Net.QueryParsers.ParseException) { return(0); } catch (Exception ex) { throw ex; } }
public void When_adding_not_in_clause() { var query = FilteredQuery.Make(_table); query.AddInClause <Person, string>(p => p.Name, Formatter.AndClauseSeparator, false, new[] { "Foo", "Bar" }); query.Parameters.Count.ShouldBe(1); query.Parameters["Name1"].ShouldBe(new[] { "Foo", "Bar" }); var sql = query.Compile(); sql.ShouldBe(@"SELECT [Person].[Id] AS 'Id', [Person].[Name] AS 'Name', [Person].[Age] AS 'Age' FROM [Person] WHERE 1 = 1 AND ([Name] NOT IN @Name1);"); }
private void _checkHits(bool bbox, String ptStr, double distKM, int assertNumFound, params int[] assertIds) { SpatialOperation op = SpatialOperation.Intersects; var pt = (Point)ctx.ReadShape(ptStr); double distDEG = DistanceUtils.Dist2Degrees(distKM, DistanceUtils.EARTH_MEAN_RADIUS_KM); Shape shape = ctx.MakeCircle(pt, distDEG); if (bbox) { shape = shape.GetBoundingBox(); } SpatialArgs args = new SpatialArgs(op, shape); //args.setDistPrecision(0.025); Query query; if (random.NextDouble() > 0.5) { query = strategy.MakeQuery(args); } else { query = new FilteredQuery(new MatchAllDocsQuery(), strategy.MakeFilter(args)); } SearchResults results = executeQuery(query, 100); assertEquals("" + shape, assertNumFound, results.numFound); if (assertIds != null) { var resultIds = new HashSet <int>(); foreach (var result in results.results) { resultIds.Add(int.Parse(result.document.Get("id"))); } foreach (int assertId in assertIds) { assertTrue("has " + assertId, resultIds.Contains(assertId)); } } }
private void _CheckHits(bool bbox, IPoint pt, double distKM, int assertNumFound, params int[] assertIds) { SpatialOperation op = SpatialOperation.Intersects; double distDEG = DistanceUtils.Dist2Degrees(distKM, DistanceUtils.EARTH_MEAN_RADIUS_KM); IShape shape = ctx.MakeCircle(pt, distDEG); if (bbox) { shape = shape.BoundingBox; } SpatialArgs args = new SpatialArgs(op, shape); //args.setDistPrecision(0.025); Query query; if (Random().nextBoolean()) { query = strategy.MakeQuery(args); } else { query = new FilteredQuery(new MatchAllDocsQuery(), strategy.MakeFilter(args)); } SearchResults results = executeQuery(query, 100); assertEquals("" + shape, assertNumFound, results.numFound); if (assertIds != null) { ISet <int?> resultIds = new HashSet <int?>(); foreach (SearchResult result in results.results) { resultIds.add(int.Parse(result.document.Get("id"), CultureInfo.InvariantCulture)); } foreach (int assertId in assertIds) { assertTrue("has " + assertId, resultIds.contains(assertId)); } } }
public static LuceneResultNode SearchMaxHit(IndexBase index, SearchNode node, int maxHit) { try { var query = MultiFieldQueryParser.Parse(Lucene.Net.Util.Version.LUCENE_29, node.Queries, node.Fields, node.Occurs, new PanGuAnalyzer(true)); foreach (ContainFilterNode cf in node.ContainFilters) { query = new FilteredQuery(query, new ContainFilter(new Term(cf.FieldName, cf.Text))); } return(ResponseSearch(index, query, node, maxHit)); } catch (Lucene.Net.QueryParsers.ParseException) { return(new LuceneResultNode() { AllCount = 0, Result = new List <string>() }); } catch (Exception ex) { throw ex; } }
public override Query Rewrite(IndexReader r) { if (!query.Clauses.Any()) { return new MatchAllDocsQuery(); } IList<Filter> filters = new List<Filter>(); IList<Query> queries = new List<Query>(); IList<BooleanClause> clauses = query.Clauses; Query baseQuery; int startIndex; if (drillDownDims.Count == query.Clauses.Count()) { baseQuery = new MatchAllDocsQuery(); startIndex = 0; } else { baseQuery = clauses[0].Query; startIndex = 1; } for (int i = startIndex; i < clauses.Count; i++) { BooleanClause clause = clauses[i]; Query queryClause = clause.Query; Filter filter = GetFilter(queryClause); if (filter != null) { filters.Add(filter); } else { queries.Add(queryClause); } } if (filters.Count == 0) { return query; } else { // Wrap all filters using FilteredQuery // TODO: this is hackish; we need to do it because // BooleanQuery can't be trusted to handle the // "expensive filter" case. Really, each Filter should // know its cost and we should take that more // carefully into account when picking the right // strategy/optimization: Query wrapped; if (queries.Count == 0) { wrapped = baseQuery; } else { // disable coord BooleanQuery wrappedBQ = new BooleanQuery(true); if ((baseQuery is MatchAllDocsQuery) == false) { wrappedBQ.Add(baseQuery, Occur.MUST); } foreach (Query q in queries) { wrappedBQ.Add(q, Occur.MUST); } wrapped = wrappedBQ; } foreach (Filter filter in filters) { wrapped = new FilteredQuery(wrapped, filter, FilteredQuery.QUERY_FIRST_FILTER_STRATEGY); } return wrapped; } }
public virtual Query VisitFilteredQuery(FilteredQuery filteredq) { throw new NotImplementedException(); }
public virtual Query VisitFilteredQuery(FilteredQuery filteredq) { throw new SnNotSupportedException(); }
public virtual async Task <ICollection <TModel> > ListFilteredAsync(CancellationToken cancellationToken = default) { return(await FilteredQuery.ToArrayAsync(cancellationToken)); }
public override Query Rewrite(IndexReader r) { if (!query.Clauses.Any()) { return(new MatchAllDocsQuery()); } IList <Filter> filters = new List <Filter>(); IList <Query> queries = new List <Query>(); IList <BooleanClause> clauses = query.Clauses; Query baseQuery; int startIndex; if (drillDownDims.Count == query.Clauses.Count) { baseQuery = new MatchAllDocsQuery(); startIndex = 0; } else { baseQuery = clauses[0].Query; startIndex = 1; } for (int i = startIndex; i < clauses.Count; i++) { BooleanClause clause = clauses[i]; Query queryClause = clause.Query; Filter filter = GetFilter(queryClause); if (filter != null) { filters.Add(filter); } else { queries.Add(queryClause); } } if (filters.Count == 0) { return(query); } else { // Wrap all filters using FilteredQuery // TODO: this is hackish; we need to do it because // BooleanQuery can't be trusted to handle the // "expensive filter" case. Really, each Filter should // know its cost and we should take that more // carefully into account when picking the right // strategy/optimization: Query wrapped; if (queries.Count == 0) { wrapped = baseQuery; } else { // disable coord BooleanQuery wrappedBQ = new BooleanQuery(true); if ((baseQuery is MatchAllDocsQuery) == false) { wrappedBQ.Add(baseQuery, Occur.MUST); } foreach (Query q in queries) { wrappedBQ.Add(q, Occur.MUST); } wrapped = wrappedBQ; } foreach (Filter filter in filters) { wrapped = new FilteredQuery(wrapped, filter, FilteredQuery.QUERY_FIRST_FILTER_STRATEGY); } return(wrapped); } }
public virtual async Task <TModel> GetFilteredAsync(Expression <Func <TModel, bool> > filter, CancellationToken cancellationToken = default) { return(await FilteredQuery.FirstOrDefaultAsync(filter, cancellationToken)); }
public static List <Picture> GetPicturesOfComputer( string computerId, string text, string[] tags, DateTime startDate, DateTime endDate, int start = 0, int rows = 10) { QueryContainer textContainer; QueryContainer tagsContainer; if (string.IsNullOrEmpty(text)) { textContainer = new MatchAllQuery(); } else { textContainer = new MatchQuery() { Field = "Text", Query = text } }; if ((tags == null) || (tags.Length > 0)) { tagsContainer = new MatchAllQuery(); } else { tagsContainer = new QueryContainer(new MatchQuery() { Field = "Tags", Query = tags[0] }); for (int i = 1; i < tags.Length; i++) { tagsContainer = tagsContainer && new MatchQuery() { Field = "Tags", Query = tags[i] }; } } QueryContainer query = new FilteredQuery() { Filter = new FilterContainer( new RangeFilter() { Field = "Date", GreaterThanOrEqualTo = startDate.ToString("yyyy-MM-ddTHH:mm:ss"), LowerThanOrEqualTo = endDate.ToString("yyyy-MM-ddTHH:mm:ss") }), Query = new QueryContainer( new MatchQuery() { Field = "ComputerId", Query = computerId }) }; QueryContainer finalQuery = query && textContainer && tagsContainer; ISearchResponse <Picture> response = _elasticClient.Search <Picture>(s => s .Type(PICTURE_OBJECT_TYPE) .From(start) .Size(rows) .SortAscending("Date") .Query(finalQuery)); return(response.Documents.ToList()); }
public override Query VisitFilteredQuery(FilteredQuery filteredq) { throw new NotImplementedException(); }
public static void Search(JsonWriter jsonWriter, NuGetSearcherManager searcherManager, string q, bool countOnly, bool includePrerelease, NuGetVersion semVerLevel, string sortBy, int skip, int take, string feed, bool ignoreFilter, bool luceneQuery) { if (jsonWriter == null) { throw new ArgumentNullException(nameof(jsonWriter)); } if (searcherManager == null) { throw new ArgumentNullException(nameof(searcherManager)); } var searcher = searcherManager.Get(); try { // The old V2 search service would treat "id:" queries (~match) in the same way as it did "packageid:" (==match). // If "id:" is in the query, replace it. if (luceneQuery && !string.IsNullOrEmpty(q) && q.StartsWith("id:", StringComparison.OrdinalIgnoreCase)) { q = "packageid:" + q.Substring(3); } // Build the query Query query = NuGetQuery.MakeQuery(q, searcher.Owners); // Build filter bool includeUnlisted = ignoreFilter; includePrerelease = ignoreFilter || includePrerelease; feed = ignoreFilter ? null : feed; var combinedQuery = new BooleanQuery(); combinedQuery.Add(query, Occur.SHOULD); // Add this clause to the query here so we still respect semVerLevel that is passed when ignoring filters. if (!SemVerHelpers.ShouldIncludeSemVer2Results(semVerLevel)) { combinedQuery.Add( NuGetQuery.ConstructClauseQuery( new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30), MetadataConstants.LuceneMetadata.SemVerLevelPropertyName, new List <string> { SemVerHelpers.SemVerLevelKeySemVer2 }), Occur.MUST_NOT); } query = combinedQuery; Filter filter = null; if (!ignoreFilter && searcher.TryGetFilter(includeUnlisted, includePrerelease, semVerLevel, feed, out filter)) { // Filter before running the query (make the search set smaller) query = new FilteredQuery(query, filter); } if (countOnly) { DocumentCountImpl(jsonWriter, searcher, query); } else { ListDocumentsImpl(jsonWriter, searcher, query, sortBy, skip, take, semVerLevel); } } finally { searcherManager.Release(searcher); } }
public virtual async Task <ICollection <TProject> > ListFilteredAsync <TProject>(CancellationToken cancellationToken = default) where TProject : IModel <TKey> { return(await FilteredQuery.ProjectTo <TProject>().ToArrayAsync(cancellationToken)); }
public override Query VisitFilteredQuery(FilteredQuery filteredq) { throw new SnNotSupportedException(); }
//TODO this is basically old code that hasn't been verified well and should probably be removed public virtual Query MakeQueryDistanceScore(SpatialArgs args) { // For starters, just limit the bbox var shape = args.Shape; if (!(shape is IRectangle || shape is ICircle)) { throw new NotSupportedException("Only Rectangles and Circles are currently supported, found [" + shape.GetType().Name + "]");//TODO } IRectangle bbox = shape.BoundingBox; if (bbox.CrossesDateLine) { throw new NotSupportedException("Crossing dateline not yet supported"); } ValueSource valueSource = null; Query spatial = null; SpatialOperation op = args.Operation; if (SpatialOperation.Is(op, SpatialOperation.BBoxWithin, SpatialOperation.BBoxIntersects)) { spatial = MakeWithin(bbox); } else if (SpatialOperation.Is(op, SpatialOperation.Intersects, SpatialOperation.IsWithin)) { spatial = MakeWithin(bbox); if (args.Shape is ICircle) { var circle = (ICircle)args.Shape; // Make the ValueSource valueSource = MakeDistanceValueSource(shape.Center); var vsf = new ValueSourceFilter( new QueryWrapperFilter(spatial), valueSource, 0, circle.Radius); spatial = new FilteredQuery(new MatchAllDocsQuery(), vsf); } } else if (op == SpatialOperation.IsDisjointTo) { spatial = MakeDisjoint(bbox); } if (spatial == null) { throw new UnsupportedSpatialOperation(args.Operation); } if (valueSource != null) { valueSource = new CachingDoubleValueSource(valueSource); } else { valueSource = MakeDistanceValueSource(shape.Center); } Query spatialRankingQuery = new FunctionQuery(valueSource); var bq = new BooleanQuery(); bq.Add(spatial, BooleanClause.Occur.MUST); bq.Add(spatialRankingQuery, BooleanClause.Occur.MUST); return(bq); }
public virtual async Task <TProject> GetFilteredAsync <TProject>(TKey id, CancellationToken cancellationToken = default) where TProject : IModel <TKey> { return(await FilteredQuery.ProjectTo <TProject>().FirstOrDefaultAsync(x => x.Id.Equals(id), cancellationToken)); }
public void TestGetBestFragmentsFilteredPhraseQuery() { var helper = new TestHighlightRunner(); helper.TestAction = () => { numHighlights = 0; var rf = new TermRangeFilter("contents", "john", "john", true, true); var pq = new PhraseQuery(); pq.Add(new Term("contents", "john")); pq.Add(new Term("contents", "kennedy")); var fq = new FilteredQuery(pq, rf); DoSearching(fq); helper.DoStandardHighlights(analyzer, searcher, hits, query, this); // Currently highlights "John" and "Kennedy" separately Assert.IsTrue(numHighlights == 2, "Failed to find correct number of highlights " + numHighlights + " found"); }; helper.Start(); }
public virtual async Task <TModel> GetFilteredAsync(TKey id, CancellationToken cancellationToken = default) { return(await FilteredQuery.FirstOrDefaultAsync(x => x.Id.Equals(id), cancellationToken)); }
/// <summary> /// Deletes the documents for objects of the given type matching the given selection. /// </summary> /// <param name="writer"> /// The IndexWriter to delete the documents from. /// </param> /// <param name="type"> /// The type of the object to delete documents for. /// </param> /// <param name="selection"> /// The Query which selects the documents to delete. /// </param> public static void DeleteDocuments(this IndexWriter writer, Type type, Query selection) { Query deleteQuery = new FilteredQuery(selection, ObjectMapping.GetTypeFilter(type)); writer.DeleteDocuments(deleteQuery); }
public virtual async Task <TProject> GetFilteredAsync <TProject>(Expression <Func <TModel, bool> > filter, CancellationToken cancellationToken = default) where TProject : IModel <TKey> { return(await FilteredQuery.Where(filter).ProjectTo <TProject>().FirstOrDefaultAsync(cancellationToken)); }
private static void GetTermsFromFilteredQuery(FilteredQuery query, HashSet<WeightedTerm> terms, bool prohibited, string fieldName) { GetTerms(query.Query, terms, prohibited, fieldName); }
/// <summary> /// Deletes the documents for objects of the given type matching the given selection. /// </summary> /// <typeparam name="TObject"> /// The type of the object to delete documents for. /// </typeparam> /// <param name="writer"> /// The IndexWriter to delete the documents from. /// </param> /// <param name="kind"> /// The kind of type to restrict the search to. /// </param> /// <param name="selection"> /// The Query which selects the documents to delete. /// </param> public static void DeleteDocuments <TObject>(this IndexWriter writer, DocumentObjectTypeKind kind, Query selection) { Query deleteQuery = new FilteredQuery(selection, ObjectMapping.GetTypeFilter <TObject>(kind)); writer.DeleteDocuments(deleteQuery); }
private static void GetTermsFromFilteredQuery(FilteredQuery query, ISet <WeightedTerm> terms, bool prohibited, string fieldName) { GetTerms(query.Query, terms, prohibited, fieldName); }
public void TestGetBestFragmentsFilteredQuery() { var helper = new TestHighlightRunner(); helper.TestAction = () => { numHighlights = 0; TermRangeFilter rf = new TermRangeFilter("contents", "john", "john", true, true); SpanQuery[] clauses = { new SpanTermQuery(new Term("contents", "john")), new SpanTermQuery(new Term("contents", "kennedy")) }; SpanNearQuery snq = new SpanNearQuery(clauses, 1, true); FilteredQuery fq = new FilteredQuery(snq, rf); DoSearching(fq); helper.DoStandardHighlights(analyzer, searcher, hits, query, this); // Currently highlights "John" and "Kennedy" separately Assert.IsTrue(numHighlights == 2, "Failed to find correct number of highlights " + numHighlights + " found"); }; helper.Start(); }