TopFieldDocs fdocs = searcher.search(query, start + maxItems, sort); totalHits = fdocs.totalHits; hits = fdocs.scoreDocs; Document doc = searcher.doc(hits[0].doc); if (doc.getField(QueryBuilder.TAGS) != null) { byte[] rawTags = doc.getField(QueryBuilder.TAGS).binaryValue().bytes; Definitions tags = Definitions.deserialize(rawTags); String symbol = ((TermQuery) query).getTerm().text(); if (tags.occurrences(symbol) == 1) { uniqueDefinition = true; + Util.URIEncodePath(searcher.doc(hits[0].doc).get(QueryBuilder.PATH)) + '#' + Util.URIEncode(((TermQuery) query).getTerm().text());
private ImageSearchHits search(String[] hashes, GlobalFeature queryFeature, IndexReader reader) throws IOException { IndexSearcher searcher = new IndexSearcher(reader); searcher.setSimilarity(new BaseSimilarity()); BooleanQuery query = null; BooleanQuery.Builder builder = new BooleanQuery.Builder(); for (int i = 0; i < hashes.length; i++) { builder.add(new BooleanClause(new TermQuery(new Term(hashesFieldName, hashes[i] + "")), BooleanClause.Occur.SHOULD)); } else builder.add(new BooleanClause(new TermQuery(new Term(hashesFieldName, hashes[i] + "")), BooleanClause.Occur.SHOULD)); query = builder.build(); TopDocs docs = searcher.search(query, maxResultsHashBased); double tmpScore; for (int i = 0; i < docs.scoreDocs.length; i++) { feature.setByteArrayRepresentation(reader.document(docs.scoreDocs[i].doc).getBinaryValue(featureFieldName).bytes, reader.document(docs.scoreDocs[i].doc).getBinaryValue(featureFieldName).offset, reader.document(docs.scoreDocs[i].doc).getBinaryValue(featureFieldName).length); tmpScore = queryFeature.getDistance(feature); assert (tmpScore >= 0);
private BooleanQuery buildLineageQuery(final Collection<String> flowFileUuids) { // Create a query for all Events related to the FlowFiles of interest. We do this by adding all ID's as // "SHOULD" clauses and then setting the minimum required to 1. final BooleanQuery lineageQuery; if (flowFileUuids == null || flowFileUuids.isEmpty()) { lineageQuery = null; } else { lineageQuery = new BooleanQuery(); for (final String flowFileUuid : flowFileUuids) { lineageQuery.add(new TermQuery(new Term(SearchableFields.FlowFileUUID.getSearchableFieldName(), flowFileUuid)), Occur.SHOULD); } lineageQuery.setMinimumNumberShouldMatch(1); } return lineageQuery; }
private List<SimpleChildEntity> getSimpleChildEntitiesFromIndex(FullTextSession session, String name) { FullTextQuery q = session.createFullTextQuery( new TermQuery( new Term( "parentName", name ) ), SimpleChildEntity.class ); @SuppressWarnings("unchecked") List<SimpleChildEntity> results = q.list(); return results; }
public ImageSearchHits search(Document doc, IndexReader reader) throws IOException { GlobalFeature queryFeature = null; try { queryFeature = feature.getClass().newInstance(); } catch (InstantiationException | IllegalAccessException e) { e.printStackTrace(); return null; } if (useDocValues) { docValues = MultiDocValues.getBinaryValues(reader, featureFieldName); // find the id of the document in the reader, then do search ... TODO: find another way instead of calling the searcher every time. TopDocs topDocs = searcher.search(new TermQuery(new Term(DocumentBuilder.FIELD_NAME_IDENTIFIER, doc.get(DocumentBuilder.FIELD_NAME_IDENTIFIER))), 1); if (topDocs.totalHits > 0) { int docID = topDocs.scoreDocs[0].doc; docValues.advanceExact(docID); queryFeature.setByteArrayRepresentation(docValues.binaryValue().bytes, docValues.binaryValue().offset, docValues.binaryValue().length); return search(MetricSpaces.generateBoostedQuery(queryFeature, numHashesUsedForQuery), queryFeature, searcher.getIndexReader()); } } else { queryFeature.setByteArrayRepresentation(doc.getBinaryValue(featureFieldName).bytes, doc.getBinaryValue(featureFieldName).offset, doc.getBinaryValue(featureFieldName).length); return search(MetricSpaces.generateBoostedQuery(queryFeature, numHashesUsedForQuery), queryFeature, reader); } return null; }
BooleanQuery.Builder builder = new BooleanQuery.Builder(); String pkey = Token.getKeyForClass(PatternsAnnotations.ProcessedTextAnnotation.class); for(String en2: en.getValue()){ if(!processedKey || !stopWords.contains(en2.toLowerCase())) builder.add(new BooleanClause(new TermQuery(new Term(en.getKey(), en2)), BooleanClause.Occur.MUST)); BooleanQuery query = builder.build(); TopDocs tp = searcher.search(query, Integer.MAX_VALUE); Set<String> sentids = new HashSet<>(); if (tp.totalHits > 0) { for (ScoreDoc s : tp.scoreDocs) { int docId = s.doc; Document d = searcher.doc(docId); sentids.add(d.get("sentid"));
boolean stops, boolean clusters, boolean corners) { BooleanQuery query = new BooleanQuery(); BooleanQuery termQuery = new BooleanQuery(); termQuery.add(new PrefixQuery(new Term("name", queryString)), BooleanClause.Occur.SHOULD); } else { List<String> list = new ArrayList<String>(); PhraseQuery phraseQuery = new PhraseQuery(); for (String phraseToken : token.substring(1, token.length() - 1).split(" ")) { phraseQuery.add(new Term("name", phraseToken.toLowerCase())); termQuery.add(phraseQuery, BooleanClause.Occur.SHOULD); termQuery.add(new TermQuery(new Term("code", token)), BooleanClause.Occur.SHOULD); BooleanQuery typeQuery = new BooleanQuery(); if (stops) { typeQuery.add(new TermQuery(new Term("category", Category.STOP.name())), BooleanClause.Occur.SHOULD); typeQuery.add(new TermQuery(new Term("category", Category.CLUSTER.name())), BooleanClause.Occur.SHOULD); typeQuery.add(new TermQuery(new Term("category", Category.CORNER.name())), BooleanClause.Occur.SHOULD); query.add(typeQuery, BooleanClause.Occur.MUST);
public ImageSearchHits search(Document doc, IndexReader reader) throws IOException { IndexSearcher is = new IndexSearcher(reader); TermQuery tq = new TermQuery(new Term(DocumentBuilder.FIELD_NAME_IDENTIFIER, doc.getValues(DocumentBuilder.FIELD_NAME_IDENTIFIER)[0])); TopDocs topDocs = is.search(tq, 1); if (topDocs.totalHits > 0) { return search(topDocs.scoreDocs[0].doc); } else return null; }
@Override public Map<Integer, Set<E>> getPatternsForAllTokens(String sentId) { try { TermQuery query = new TermQuery(new Term("sentid", sentId)); TopDocs tp = searcher.search(query,1); if (tp.totalHits > 0) { for (ScoreDoc s : tp.scoreDocs) { int docId = s.doc; Document d = searcher.doc(docId); byte[] st = d.getBinaryValue("patterns").bytes; ByteArrayInputStream baip = new ByteArrayInputStream(st); ObjectInputStream ois = new ObjectInputStream(baip); return (Map<Integer, Set<E>>) ois.readObject(); } } else throw new RuntimeException("Why no patterns for sentid " + sentId + ". Number of documents in index are " + size()); }catch(IOException e){ throw new RuntimeException(e); } catch (ClassNotFoundException e) { throw new RuntimeException(e); } return null; }
flowFileIdQuery = null; } else { flowFileIdQuery = new BooleanQuery(); for (final String flowFileUuid : flowFileUuids) { flowFileIdQuery.add(new TermQuery(new Term(SearchableFields.FlowFileUUID.getSearchableFieldName(), flowFileUuid)), Occur.SHOULD); flowFileIdQuery.setMinimumNumberShouldMatch(1); final TopDocs uuidQueryTopDocs = searcher.getIndexSearcher().search(flowFileIdQuery, MAX_QUERY_RESULTS); final long searchEnd = System.nanoTime(); final Set<ProvenanceEventRecord> recs = docsToEventConverter.convert(uuidQueryTopDocs, searcher.getIndexSearcher().getIndexReader());
@Test @SuppressWarnings("unchecked") public void testBoostQuery() { try ( Session session = openSession() ) { FullTextSession fullTextSession = Search.getFullTextSession( session ); TermQuery termQuery = new TermQuery( new Term( "message", "import" ) ); termQuery.setBoost( 3.0f ); BoostQuery testedQuery = new BoostQuery( termQuery, 2.0f ); FullTextQuery fullTextQuery = fullTextSession.createFullTextQuery( testedQuery, Letter.class ); String queryString = fullTextQuery.getQueryString(); assertJsonEquals( "{'query':{'bool':{'must':{'term':{'message':{'value':'import','boost':3.0}}},'boost':2.0}}}", queryString ); List<Letter> letters = fullTextQuery.list(); assertThat( letters ).hasSize( 1 ); assertThat( letters ).extracting( "message" ).containsExactly( "Important letter" ); } }
for ( LeafReaderContext leafReaderContext : searcher.getIndexReader().leaves() ) searcher.search( new TermQuery( new Term( field, termsRef ) ), collector );
@Override public org.apache.lucene.search.Query getLuceneQuery() { org.apache.lucene.search.TermQuery luceneQuery = new org.apache.lucene.search.TermQuery(new Term(field, term)); luceneQuery.setBoost(boost); return luceneQuery; }
private long getCount(Term term, LuceneSearcher luceneSearcher) { long result = 0; try { TopDocs docs = luceneSearcher.searcher.search(new TermQuery(term), 2000); if (docs.totalHits > 2000) { throw new RuntimeException("More than 2000 matches for '" + term + "' not supported for performance reasons: " + docs.totalHits + " matches in " + luceneSearcher.directory); } for (ScoreDoc scoreDoc : docs.scoreDocs) { String countStr = luceneSearcher.reader.document(scoreDoc.doc).get("count"); result += Long.parseLong(countStr); } //System.out.println(term + " -> " + result); } catch (IOException e) { throw new RuntimeException(e); } return result; }
final int threshold = Math.min(BOOLEAN_REWRITE_TERM_COUNT_THRESHOLD, BooleanQuery.getMaxClauseCount()); assert termData.size() > threshold : "Query should have been rewritten"; List<TermAndState> matchingTerms = new ArrayList<>(threshold); BooleanQuery.Builder bq = new BooleanQuery.Builder(); for (TermAndState t : matchingTerms) { final TermContext termContext = new TermContext(searcher.getTopReaderContext()); termContext.register(t.state, context.ord, t.docFreq, t.totalTermFreq); bq.add(new TermQuery(new Term(t.field, t.term), termContext), Occur.SHOULD); Query q = new ConstantScoreQuery(bq.build()); final Weight weight = searcher.rewrite(q).createWeight(searcher, needsScores, score()); return new WeightOrDocIdSet(weight); } else {
private Query injectOrphans( Query query ) { if ( query instanceof BooleanQuery ) { BooleanQuery source = (BooleanQuery) query; BooleanQuery.Builder builder = new BooleanQuery.Builder(); for ( BooleanClause clause : source.clauses() ) { builder.add( injectOrphans( clause.getQuery() ), clause.getOccur() ); } return builder.build(); } String orphanField = extractTermField( query ); if ( orphanField == null ) { return query; } return new BooleanQuery.Builder() .add( query, Occur.SHOULD ) .add( new TermQuery( new Term( ORPHANS_KEY, orphanField ) ), Occur.SHOULD ) .build(); }
@Test public void testFilterDefinedOnSuperClass() { TermQuery query = new TermQuery( new Term( "employer", "Red Hat" ) ); FullTextQuery ftQuery = fullTextSession.createFullTextQuery( query, Employee.class ); ftQuery.enableFullTextFilter( "roleFilter" ) .setParameter( "role", Role.ADMINISTRATOR ); assertEquals( "Should find the filter defined in the super class", 1, ftQuery.getResultSize() ); }
private ContainingEntity doQuery(String twiceNestedEntityName) { Transaction tx = getSession().beginTransaction(); FullTextSession fullTextSession = Search.getFullTextSession( getSession() ); Query termQuery = new TermQuery( new Term( "nested.name", twiceNestedEntityName ) ); FullTextQuery fullTextQuery = fullTextSession.createFullTextQuery( termQuery, ContainingEntity.class ); ContainingEntity result = (ContainingEntity) fullTextQuery.uniqueResult(); tx.commit(); return result; }
@Override public Query rewrite(IndexReader reader) throws IOException { final int threshold = Math.min(BOOLEAN_REWRITE_TERM_COUNT_THRESHOLD, BooleanQuery.getMaxClauseCount()); if (termData.size() <= threshold) { BooleanQuery.Builder bq = new BooleanQuery.Builder(); TermIterator iterator = termData.iterator(); for (BytesRef term = iterator.next(); term != null; term = iterator.next()) { bq.add(new TermQuery(new Term(iterator.field(), BytesRef.deepCopyOf(term))), Occur.SHOULD); } return new ConstantScoreQuery(bq.build()); } return super.rewrite(reader); }