/**
* 将分支数据转成Query逻辑
*
* @return
*/
List<Query> toQueries(String fieldName) {
List<Query> queries = new ArrayList<Query>(1);
// 生成当前branch 的query
if (lexeme != null) {
queries.add(new TermQuery(new Term(fieldName, lexeme.getLexemeText())));
}
// 生成child branch 的query
if (acceptedBranchs != null && acceptedBranchs.size() > 0) {
if (acceptedBranchs.size() == 1) {
Query onlyOneQuery = optimizeQueries(acceptedBranchs.get(0).toQueries(fieldName));
if (onlyOneQuery != null) {
queries.add(onlyOneQuery);
}
} else {
BooleanQuery orQuery = new BooleanQuery();
for (TokenBranch childBranch : acceptedBranchs) {
Query childQuery = optimizeQueries(childBranch.toQueries(fieldName));
if (childQuery != null) {
orQuery.add(childQuery, Occur.SHOULD);
}
}
if (orQuery.getClauses().length > 0) {
queries.add(orQuery);
}
}
}
// 生成nextBranch的query
if (nextBranch != null) {
queries.addAll(nextBranch.toQueries(fieldName));
}
return queries;
}
@Override
public Query prefixQuery(
Object value,
@Nullable MultiTermQuery.RewriteMethod method,
@Nullable QueryParseContext context) {
if (fieldType.indexOptions() != IndexOptions.NONE || context == null) {
return super.prefixQuery(value, method, context);
}
Collection<String> queryTypes = context.queryTypes();
if (queryTypes.size() == 1) {
PrefixQuery prefixQuery =
new PrefixQuery(
new Term(
UidFieldMapper.NAME,
Uid.createUidAsBytes(
Iterables.getFirst(queryTypes, null), BytesRefs.toBytesRef(value))));
if (method != null) {
prefixQuery.setRewriteMethod(method);
}
return prefixQuery;
}
BooleanQuery query = new BooleanQuery();
for (String queryType : queryTypes) {
PrefixQuery prefixQuery =
new PrefixQuery(
new Term(
UidFieldMapper.NAME,
Uid.createUidAsBytes(queryType, BytesRefs.toBytesRef(value))));
if (method != null) {
prefixQuery.setRewriteMethod(method);
}
query.add(prefixQuery, BooleanClause.Occur.SHOULD);
}
return query;
}
/** 获取全文查询对象 */
public BooleanQuery getFullTextQuery(BooleanClause... booleanClauses) {
BooleanQuery booleanQuery = new BooleanQuery();
for (BooleanClause booleanClause : booleanClauses) {
booleanQuery.add(booleanClause);
}
return booleanQuery;
}
@Test
public void testQueryText() {
Float boost = 0.7f;
Object[] values = new Object[] {"houses", "cats"};
Schema schema = schema().mapper("name", textMapper()).defaultAnalyzer("english").build();
ContainsCondition condition = new ContainsCondition(boost, "name", values);
Query query = condition.query(schema);
assertNotNull("Query is not built", query);
assertEquals("Query type is wrong", BooleanQuery.class, query.getClass());
BooleanQuery booleanQuery = (BooleanQuery) query;
assertEquals("Query boost is wrong", 0.7f, query.getBoost(), 0);
BooleanClause[] clauses = booleanQuery.getClauses();
assertEquals(
"Query is wrong",
"hous",
((TermQuery) clauses[0].getQuery()).getTerm().bytes().utf8ToString());
assertEquals(
"Query is wrong",
"cat",
((TermQuery) clauses[1].getQuery()).getTerm().bytes().utf8ToString());
}
public List<Document> searchDocuments(String text) {
List<Document> documents = new ArrayList<Document>();
try {
TokenStream tokenStream = analyzer.tokenStream("text", text);
CharTermAttribute charTermAtt = tokenStream.addAttribute(CharTermAttribute.class);
tokenStream.reset();
BooleanQuery bQuery = new BooleanQuery();
while (tokenStream.incrementToken()) {
String token = charTermAtt.toString();
TermQuery tq = new TermQuery(new Term("text", token));
tq.setBoost(2f);
bQuery.add(tq, Occur.MUST);
}
tokenStream.close();
TopDocs results = searcher.search(bQuery, 100000);
ScoreDoc[] hits = results.scoreDocs;
for (ScoreDoc hit : hits) {
Document doc = searcher.doc(hit.doc);
doc.add(new FloatField("score", hit.score, FloatField.TYPE_STORED));
documents.add(doc);
}
} catch (Exception e) {
e.printStackTrace();
}
return documents;
}
public void performWork(LuceneWork work, IndexWriter writer) {
final Class<?> entityType = work.getEntityClass();
final Serializable id = work.getId();
log.tracef("Removing %s#%s by query.", entityType, id);
DocumentBuilderIndexedEntity<?> builder = workspace.getDocumentBuilder(entityType);
BooleanQuery entityDeletionQuery = new BooleanQuery();
Query idQueryTerm;
if (isIdNumeric(builder)) {
idQueryTerm = NumericFieldUtils.createExactMatchQuery(builder.getIdKeywordName(), id);
} else {
idQueryTerm = new TermQuery(builder.getTerm(id));
}
entityDeletionQuery.add(idQueryTerm, BooleanClause.Occur.MUST);
Term classNameQueryTerm = new Term(ProjectionConstants.OBJECT_CLASS, entityType.getName());
TermQuery classNameQuery = new TermQuery(classNameQueryTerm);
entityDeletionQuery.add(classNameQuery, BooleanClause.Occur.MUST);
try {
writer.deleteDocuments(entityDeletionQuery);
} catch (Exception e) {
String message = "Unable to remove " + entityType + "#" + id + " from index.";
throw new SearchException(message, e);
}
}
public Query parse() throws ParseException {
String pattern = qstr;
int idx = qstr.indexOf("title:");
if (idx < 0) return keyParser.parse(qstr);
pattern = qstr.substring(0, idx);
String title = qstr.substring(idx + 6);
StringBuilder builder = new StringBuilder();
for (int i = 0; i < title.length(); i++) {
char c = title.charAt(i);
for (int k = 0; k < TpWorkingData.SPECIALS.length; k++) {
if (c != TpWorkingData.SPECIALS[k]) continue;
builder.append('\\');
break;
}
builder.append(c);
}
title = builder.toString();
BooleanQuery patternQuery = new BooleanQuery();
patternQuery.add(keyParser.parse(pattern), BooleanClause.Occur.SHOULD);
if (title.trim().length() > 0) {
patternQuery.add(titleParser.parse(title), BooleanClause.Occur.SHOULD);
}
// return keyParser.parse(qstr);
// System.out.println(" thay co "+ patternQuery);
return patternQuery;
}
public CObj getMyIdentity(String id) {
BooleanQuery bq = new BooleanQuery();
Term typterm = new Term(CObj.PARAM_TYPE, CObj.IDENTITY);
bq.add(new TermQuery(typterm), BooleanClause.Occur.MUST);
Term idterm = new Term(CObj.PARAM_ID, id);
bq.add(new TermQuery(idterm), BooleanClause.Occur.MUST);
Term mustterm = new Term(CObj.docPrivate(CObj.MINE), "true");
bq.add(new TermQuery(mustterm), BooleanClause.Occur.MUST);
CObj r = null;
CObjList l = search(bq, 1);
if (l.size() > 0) {
try {
r = l.get(0);
} catch (Exception e) {
e.printStackTrace();
}
}
l.close();
return r;
}
public void testStraightFilters() {
createData();
FullTextSession s = Search.getFullTextSession(openSession());
s.getTransaction().begin();
BooleanQuery query = new BooleanQuery();
query.add(new TermQuery(new Term("teacher", "andre")), BooleanClause.Occur.SHOULD);
query.add(new TermQuery(new Term("teacher", "max")), BooleanClause.Occur.SHOULD);
query.add(new TermQuery(new Term("teacher", "aaron")), BooleanClause.Occur.SHOULD);
FullTextQuery ftQuery;
ftQuery = s.createFullTextQuery(query, Driver.class);
ftQuery.enableFullTextFilter("bestDriver");
Filter dateFilter = new TermRangeFilter("delivery", "2001", "2005", true, true);
ftQuery.setFilter(dateFilter);
assertEquals("Should select only liz", 1, ftQuery.getResultSize());
ftQuery = s.createFullTextQuery(query, Driver.class);
ftQuery.setFilter(dateFilter);
ftQuery.enableFullTextFilter("bestDriver");
ftQuery.enableFullTextFilter("security").setParameter("login", "andre");
ftQuery.disableFullTextFilter("security");
ftQuery.disableFullTextFilter("bestDriver");
ftQuery.setFilter(null);
assertEquals("Should not filter anymore", 3, ftQuery.getResultSize());
s.getTransaction().commit();
s.close();
deleteData();
}
public CObjList searchFiles(String comid, String share, String qstr, Sort srt) {
BooleanQuery query = new BooleanQuery();
Term pstterm = new Term(CObj.PARAM_TYPE, CObj.FILE);
query.add(new TermQuery(pstterm), BooleanClause.Occur.MUST);
Term comterm = new Term(CObj.docString(CObj.COMMUNITYID), comid);
query.add(new TermQuery(comterm), BooleanClause.Occur.MUST);
NumericRangeQuery<Long> nq =
NumericRangeQuery.newLongRange(
CObj.docNumber(CObj.NUMBER_HAS), 0L, Long.MAX_VALUE, false, true);
query.add(nq, BooleanClause.Occur.MUST);
if (share != null) {
Term shareterm = new Term(CObj.docString(CObj.SHARE_NAME), share);
query.add(new TermQuery(shareterm), BooleanClause.Occur.MUST);
}
Matcher m = Pattern.compile("\\S+").matcher(qstr);
if (m.find()) {
StringBuilder sb = new StringBuilder();
sb.append(CObj.docStringText(CObj.NAME));
sb.append(":\"");
sb.append(qstr);
sb.append("\"");
return search(query, sb.toString(), Integer.MAX_VALUE, srt);
} else {
return search(query, Integer.MAX_VALUE, srt);
}
}
public CObjList getAllHasFiles() {
BooleanQuery bq = new BooleanQuery();
Term typterm = new Term(CObj.PARAM_TYPE, CObj.HASFILE);
bq.add(new TermQuery(typterm), BooleanClause.Occur.MUST);
return search(bq, Integer.MAX_VALUE);
}
public CObjList searchPosts(String comid, String qstr, Sort srt) {
BooleanQuery query = new BooleanQuery();
Term pstterm = new Term(CObj.PARAM_TYPE, CObj.POST);
query.add(new TermQuery(pstterm), BooleanClause.Occur.MUST);
Term comterm = new Term(CObj.docString(CObj.COMMUNITYID), comid);
query.add(new TermQuery(comterm), BooleanClause.Occur.MUST);
Matcher m = Pattern.compile("\\S+").matcher(qstr);
if (m.find()) {
StringBuilder sb = new StringBuilder();
sb.append(CObj.docStringText(CObj.SUBJECT));
sb.append(":\"");
sb.append(qstr);
sb.append("\" OR ");
sb.append(CObj.docText(CObj.BODY));
sb.append(":\"");
sb.append(qstr);
sb.append("\" OR ");
sb.append(CObj.docStringText(CObj.NAME));
sb.append(":\"");
sb.append(qstr);
sb.append("\"");
return search(query, sb.toString(), Integer.MAX_VALUE, srt);
} else {
return search(query, Integer.MAX_VALUE, srt);
}
}
public CObjList getIdentities() {
BooleanQuery bq = new BooleanQuery();
Term typterm = new Term(CObj.PARAM_TYPE, CObj.IDENTITY);
bq.add(new TermQuery(typterm), BooleanClause.Occur.MUST);
return search(bq, Integer.MAX_VALUE);
}
public CObj getSubscriptionUnsub(String comid, String memid) {
BooleanQuery bq = new BooleanQuery();
Term typterm = new Term(CObj.PARAM_TYPE, CObj.SUBSCRIPTION);
bq.add(new TermQuery(typterm), BooleanClause.Occur.MUST);
Term cidterm = new Term(CObj.docString(CObj.COMMUNITYID), comid);
bq.add(new TermQuery(cidterm), BooleanClause.Occur.MUST);
Term midterm = new Term(CObj.docString(CObj.CREATOR), memid);
bq.add(new TermQuery(midterm), BooleanClause.Occur.MUST);
CObj r = null;
CObjList l = search(bq, 1);
if (l.size() > 0) {
try {
r = l.get(0);
} catch (Exception e) {
e.printStackTrace();
}
}
l.close();
return r;
}
public SearchResponse search(SearchRequest request) {
SolrQuery query = new SolrQuery();
query.setRows(request.getLimit());
query.setStart(request.getOffset() * request.getLimit());
BooleanQuery aggregate = new BooleanQuery();
if (!StringUtils.isBlank(request.getText())) {
TermQuery termQuery = new TermQuery(new Term("", request.getText()));
aggregate.add(termQuery, BooleanClause.Occur.SHOULD);
}
if (!StringUtils.isBlank(request.getEventId())) {
aggregate.add(
new TermQuery(new Term("eventid", request.getEventId())), BooleanClause.Occur.MUST);
}
query.setQuery(aggregate.toString());
log.info("QUERY IS: " + query.toString());
try {
QueryResponse queryResponse = solrServer.query(query);
log.info("RESPONSE FROM QUERY WAS: " + queryResponse);
SolrDocumentList results = queryResponse.getResults();
log.info("RESULTS WAS: " + results);
ArrayList<SearchResponse.Hit> hits = new ArrayList<SearchResponse.Hit>();
for (SolrDocument result : results) {
hits.add(
new SearchResponse.Hit(
ObjectType.session, String.valueOf(result.getFieldValue("id")), null));
}
return new SearchResponse(results.getNumFound(), queryResponse.getElapsedTime(), hits);
} catch (SolrServerException e) {
e.printStackTrace();
}
return null;
}
public void testNamedFilters() {
createData();
FullTextSession s = Search.getFullTextSession(openSession());
s.getTransaction().begin();
BooleanQuery query = new BooleanQuery();
query.add(new TermQuery(new Term("teacher", "andre")), BooleanClause.Occur.SHOULD);
query.add(new TermQuery(new Term("teacher", "max")), BooleanClause.Occur.SHOULD);
query.add(new TermQuery(new Term("teacher", "aaron")), BooleanClause.Occur.SHOULD);
FullTextQuery ftQuery = s.createFullTextQuery(query, Driver.class);
assertEquals("No filter should happen", 3, ftQuery.getResultSize());
ftQuery = s.createFullTextQuery(query, Driver.class);
ftQuery.disableFullTextFilter("bestDriver"); // was not enabled, but should be harmless
ftQuery.enableFullTextFilter("bestDriver");
assertEquals("Should filter out Gavin", 2, ftQuery.getResultSize());
ftQuery = s.createFullTextQuery(query, Driver.class);
ftQuery.enableFullTextFilter("bestDriver");
ftQuery.enableFullTextFilter("security").setParameter("login", "andre");
assertEquals("Should filter to limit to Emmanuel", 1, ftQuery.getResultSize());
ftQuery = s.createFullTextQuery(query, Driver.class);
ftQuery.enableFullTextFilter("bestDriver");
ftQuery.enableFullTextFilter("security").setParameter("login", "andre");
ftQuery.disableFullTextFilter("security");
ftQuery.disableFullTextFilter("bestDriver");
assertEquals("Should not filter anymore", 3, ftQuery.getResultSize());
s.getTransaction().commit();
s.close();
deleteData();
}
// LUCENE-5725
public void testMultiValues() throws Exception {
MoreLikeThis mlt = new MoreLikeThis(reader);
Analyzer analyzer = new MockAnalyzer(random(), MockTokenizer.KEYWORD, false);
mlt.setAnalyzer(analyzer);
mlt.setMinDocFreq(1);
mlt.setMinTermFreq(1);
mlt.setMinWordLen(1);
mlt.setFieldNames(new String[] {"text"});
BooleanQuery query =
(BooleanQuery)
mlt.like(
"text",
new StringReader("lucene"),
new StringReader("lucene release"),
new StringReader("apache"),
new StringReader("apache lucene"));
Collection<BooleanClause> clauses = query.clauses();
assertEquals("Expected 2 clauses only!", 2, clauses.size());
for (BooleanClause clause : clauses) {
Term term = ((TermQuery) clause.getQuery()).getTerm();
assertTrue(
Arrays.asList(new Term("text", "lucene"), new Term("text", "apache")).contains(term));
}
analyzer.close();
}
public static Query createMultiIntQuery(String field, int[] ids) {
BooleanQuery query = new BooleanQuery();
for (int id : ids) {
query.add(NumericRangeQuery.newIntRange(field, id, id, true, true), Occur.SHOULD);
}
return query;
}
/**
* Adds one dimension of drill downs; if you pass multiple values they are OR'd, and then the
* entire dimension is AND'd against the base query.
*/
public void add(CategoryPath... paths) {
Query q;
if (paths[0].length == 0) {
throw new IllegalArgumentException("all CategoryPaths must have length > 0");
}
String dim = paths[0].components[0];
if (drillDownDims.containsKey(dim)) {
throw new IllegalArgumentException("dimension '" + dim + "' was already added");
}
if (paths.length == 1) {
q = new TermQuery(term(fip, paths[0]));
} else {
BooleanQuery bq = new BooleanQuery(true); // disable coord
for (CategoryPath cp : paths) {
if (cp.length == 0) {
throw new IllegalArgumentException("all CategoryPaths must have length > 0");
}
if (!cp.components[0].equals(dim)) {
throw new IllegalArgumentException(
"multiple (OR'd) drill-down paths must be under same dimension; got '"
+ dim
+ "' and '"
+ cp.components[0]
+ "'");
}
bq.add(new TermQuery(term(fip, cp)), Occur.SHOULD);
}
q = bq;
}
add(dim, q);
}
public static Query createMultiTermQuery(String field, String[] terms) {
BooleanQuery query = new BooleanQuery();
for (String term : terms) {
query.add(new TermQuery(new Term(field, term)), Occur.SHOULD);
}
return query;
}
@Override
public BooleanQuery build(QueryNode queryNode) throws QueryNodeException {
AnyQueryNode andNode = (AnyQueryNode) queryNode;
BooleanQuery bQuery = new BooleanQuery();
List<QueryNode> children = andNode.getChildren();
if (children != null) {
for (QueryNode child : children) {
Object obj = child.getTag(QueryTreeBuilder.QUERY_TREE_BUILDER_TAGID);
if (obj != null) {
Query query = (Query) obj;
try {
bQuery.add(query, BooleanClause.Occur.SHOULD);
} catch (TooManyClauses ex) {
throw new QueryNodeException(
new MessageImpl(/*
* IQQQ.Q0028E_TOO_MANY_BOOLEAN_CLAUSES,
* BooleanQuery.getMaxClauseCount()
*/ QueryParserMessages.EMPTY_MESSAGE), ex);
}
}
}
}
bQuery.setMinimumNumberShouldMatch(andNode.getMinimumMatchingElements());
return bQuery;
}
/**
* Makes a flag based query clause. This is where searches can filtered by portal.
*
* <p>If you think that search is not working correctly with protals and all that kruft then this
* is a method you want to look at.
*
* <p>It only takes into account "the portal flag" and flag1Exclusive must be set. Where does that
* stuff get set? Look in vitro.flags.PortalFlag
*
* <p>One thing to keep in mind with portal filtering and search is that if you want to search a
* portal that is different then the portal the user is 'in' then the home parameter should be set
* to force the user into the new portal.
*
* <p>Ex. Bob requests the search page for vivo in portal 3. You want to have a drop down menu so
* bob can search the all CALS protal, id 60. You need to have a home=60 on your search form. If
* you don't set home=60 with your search query, then the search will not be in the all portal AND
* the WebappDaoFactory will be filtered to only show things in portal 3.
*
* <p>Notice: flag1 as a parameter is ignored. bdc34 2009-05-22.
*/
@SuppressWarnings("static-access")
private Query makeFlagQuery(PortalFlag flag) {
if (flag == null
|| !flag.isFilteringActive()
|| flag.getFlag1DisplayStatus() == flag.SHOW_ALL_PORTALS) return null;
// make one term for each bit in the numeric flag that is set
Collection<TermQuery> terms = new LinkedList<TermQuery>();
int portalNumericId = flag.getFlag1Numeric();
Long[] bits = FlagMathUtils.numeric2numerics(portalNumericId);
for (Long bit : bits) {
terms.add(new TermQuery(new Term(Entity2LuceneDoc.term.PORTAL, Long.toString(bit))));
}
// make a boolean OR query for all of those terms
BooleanQuery boolQuery = new BooleanQuery();
if (terms.size() > 0) {
for (TermQuery term : terms) {
boolQuery.add(term, BooleanClause.Occur.SHOULD);
}
return boolQuery;
} else {
// we have no flags set, so no flag filtering
return null;
}
}
public Map<String, Double> search(String text) {
Map<String, Double> similar = new HashMap<String, Double>();
try {
TokenStream tokenStream = analyzer.tokenStream("text", text);
CharTermAttribute charTermAtt = tokenStream.addAttribute(CharTermAttribute.class);
tokenStream.reset();
BooleanQuery bQuery = new BooleanQuery();
while (tokenStream.incrementToken()) {
String token = charTermAtt.toString();
TermQuery tq = new TermQuery(new Term("text", token));
tq.setBoost(2f);
bQuery.add(tq, Occur.MUST);
}
tokenStream.close();
TopDocs results = searcher.search(bQuery, 100000);
ScoreDoc[] hits = results.scoreDocs;
for (ScoreDoc hit : hits) {
Document doc = searcher.doc(hit.doc);
similar.put(doc.get("id"), new Double(hit.score));
}
} catch (Exception e) {
e.printStackTrace();
}
return similar;
}
/**
* @return
* @throws Exception
*/
public Query getQuery() throws Exception {
PaodingAnalyzer analyzer = new PaodingAnalyzer();
String field = "contents";
Query query = null;
BooleanQuery booleanQuery = new BooleanQuery();
if (this.qtype.equals("term")) {
QueryParser parser = new QueryParser(Version.LUCENE_44, field, analyzer);
query = parser.parse(queryStr);
} else if ("fuzz".equals(this.qtype)) {
Term term = new Term(field, queryStr);
query = new FuzzyQuery(term);
} else {
Term term = new Term(field, queryStr);
query = new PrefixQuery(term);
}
if (!"all".equals(this.docType)) {
Term typeTerm = new Term("type", this.docType);
TermQuery typeQuery = new TermQuery(typeTerm);
booleanQuery.add(typeQuery, BooleanClause.Occur.MUST);
}
// System.out.println("--this.docType---"+this.docType);
booleanQuery.add(query, BooleanClause.Occur.MUST);
return booleanQuery;
}
public void testNormalization() throws IOException {
assumeTrue("test runs only when at least a type is registered", getCurrentTypes().length > 0);
GeoBoundingBoxQueryBuilder qb = createTestQueryBuilder();
if (getCurrentTypes().length != 0 && "mapped_geo".equals(qb.fieldName())) {
// only execute this test if we are running on a valid geo field
qb.setCorners(200, 200, qb.bottomRight().getLat(), qb.bottomRight().getLon());
qb.setValidationMethod(GeoValidationMethod.COERCE);
Query query = qb.toQuery(createShardContext());
if (query instanceof ConstantScoreQuery) {
ConstantScoreQuery result = (ConstantScoreQuery) query;
BooleanQuery bboxFilter = (BooleanQuery) result.getQuery();
for (BooleanClause clause : bboxFilter.clauses()) {
LegacyNumericRangeQuery boundary = (LegacyNumericRangeQuery) clause.getQuery();
if (boundary.getMax() != null) {
assertTrue(
"If defined, non of the maximum range values should be larger than 180",
boundary.getMax().intValue() <= 180);
}
}
} else {
assertTrue(
"memory queries should result in LegacyInMemoryGeoBoundingBoxQuery",
query instanceof LegacyInMemoryGeoBoundingBoxQuery);
}
}
}
public Query createCommonTermsQuery(
String field,
String queryText,
Occur highFreqOccur,
Occur lowFreqOccur,
float maxTermFrequency,
MappedFieldType fieldType) {
Query booleanQuery = createBooleanQuery(field, queryText, lowFreqOccur);
if (booleanQuery != null && booleanQuery instanceof BooleanQuery) {
BooleanQuery bq = (BooleanQuery) booleanQuery;
ExtendedCommonTermsQuery query =
new ExtendedCommonTermsQuery(
highFreqOccur,
lowFreqOccur,
maxTermFrequency,
((BooleanQuery) booleanQuery).isCoordDisabled(),
fieldType);
for (BooleanClause clause : bq.clauses()) {
if (!(clause.getQuery() instanceof TermQuery)) {
return booleanQuery;
}
query.add(((TermQuery) clause.getQuery()).getTerm());
}
return query;
}
return booleanQuery;
}
public DiscoveryResponse discoverLatestVersion(DiscoveryRequest req)
throws NoSuchRepositoryException, IOException {
CLvoKey info = req.getLvoKey();
IndexingContext localContext =
indexerManager.getRepositoryLocalIndexContext(info.getRepositoryId());
IndexingContext remoteContext =
indexerManager.getRepositoryRemoteIndexContext(info.getRepositoryId());
BooleanQuery bq = new BooleanQuery();
bq.add(indexerManager.constructQuery(ArtifactInfo.GROUP_ID, info.getGroupId()), Occur.MUST);
bq.add(
indexerManager.constructQuery(ArtifactInfo.ARTIFACT_ID, info.getArtifactId()), Occur.MUST);
// to have sorted results by version in descending order
FlatSearchRequest sreq = new FlatSearchRequest(bq, ArtifactInfo.REPOSITORY_VERSION_COMPARATOR);
sreq.getContexts().add(localContext);
sreq.getContexts().add(remoteContext);
FlatSearchResponse hits = indexerManager.getNexusIndexer().searchFlat(sreq);
DiscoveryResponse response = new DiscoveryResponse(req);
if (hits.getTotalHits() > 0) {
// found it, they are sorted in descending order, so the 1st one is the newest
response.setVersion(hits.getResults().iterator().next().version);
response.setSuccessful(true);
}
return response;
}
public void testDefaultMinShouldMatch() throws Exception {
// Queries have a minShouldMatch of 0
BooleanQuery bq =
(BooleanQuery)
parseQuery(boolQuery().must(termQuery("foo", "bar")).buildAsBytes())
.toQuery(createShardContext());
assertEquals(0, bq.getMinimumNumberShouldMatch());
bq =
(BooleanQuery)
parseQuery(boolQuery().should(termQuery("foo", "bar")).buildAsBytes())
.toQuery(createShardContext());
assertEquals(0, bq.getMinimumNumberShouldMatch());
// Filters have a minShouldMatch of 0/1
ConstantScoreQuery csq =
(ConstantScoreQuery)
parseQuery(constantScoreQuery(boolQuery().must(termQuery("foo", "bar"))).buildAsBytes())
.toQuery(createShardContext());
bq = (BooleanQuery) csq.getQuery();
assertEquals(0, bq.getMinimumNumberShouldMatch());
csq =
(ConstantScoreQuery)
parseQuery(
constantScoreQuery(boolQuery().should(termQuery("foo", "bar"))).buildAsBytes())
.toQuery(createShardContext());
bq = (BooleanQuery) csq.getQuery();
assertEquals(1, bq.getMinimumNumberShouldMatch());
}
/**
* Make sure the correct search is performed when theh search request does contain "update date"
* critera and we have determined that they be included in the comment search.
*
* @throws Exception indicates some unexpected failure.
*/
@Test
public void testGetRecentCommentsIssuesUpdatedFromToDate() throws Exception {
final String beforeDuration = "-3d";
final Date beforeDate = dateSupport.convertToDate(beforeDuration);
final Date afterDate = createDate(1981, Calendar.JANUARY, 12);
final User user = new MockUser("me");
final JqlQueryBuilder builder = JqlQueryBuilder.newBuilder();
builder
.where()
.updated()
.ltEq(beforeDuration)
.and()
.updatedAfter(afterDate)
.and()
.priority("major");
final SearchRequest request = new SearchRequest(builder.buildQuery());
final List<Long> issueIds = CollectionBuilder.newBuilder(6L, 3L, 13484L, 11111134L).asList();
final BooleanQuery query = createIssueQuery(issueIds);
final BooleanQuery dateQuery = new BooleanQuery();
dateQuery.add(createBeforeQuery(beforeDate), BooleanClause.Occur.MUST);
dateQuery.add(createAfterQuery(afterDate), BooleanClause.Occur.MUST);
query.add(dateQuery, BooleanClause.Occur.MUST);
_testGetRecentComments(issueIds, request, user, true, query);
}
/**
* 多Field,多条件,多Occur查询分析
*
* @param fields
* @param queries
* @param flags
* @return Query 查询逻辑对象
* @throws IOException
*/
public static Query parseMultiField(
String[] fields, String[] queries, BooleanClause.Occur[] flags) throws IOException {
if (fields == null) {
throw new IllegalArgumentException("parameter \"fields\" is null");
}
if (queries == null) {
throw new IllegalArgumentException("parameter \"queries\" is null");
}
if (flags == null) {
throw new IllegalArgumentException("parameter \"flags\" is null");
}
if (!(queries.length == fields.length && queries.length == flags.length)) {
throw new IllegalArgumentException(
"queries, fields, and flags array have have different length");
}
BooleanQuery resultQuery = new BooleanQuery();
for (int i = 0; i < fields.length; i++) {
if (fields[i] != null) {
Query partQuery = parse(fields[i], queries[i]);
if (partQuery != null
&& (!(partQuery instanceof BooleanQuery)
|| ((BooleanQuery) partQuery).getClauses().length > 0)) {
resultQuery.add(partQuery, flags[i]);
}
}
}
return resultQuery;
}