public Query getQuery(Element e) throws ParserException {
String fieldName = DOMUtils.getAttributeWithInheritanceOrFail(e, "fieldName");
String text = DOMUtils.getNonBlankTextOrFail(e);
BooleanQuery bq = new BooleanQuery(DOMUtils.getAttribute(e, "disableCoord", false));
bq.setMinimumNumberShouldMatch(DOMUtils.getAttribute(e, "minimumNumberShouldMatch", 0));
try {
TokenStream ts = analyzer.tokenStream(fieldName, new StringReader(text));
TermToBytesRefAttribute termAtt = ts.addAttribute(TermToBytesRefAttribute.class);
Term term = null;
BytesRef bytes = termAtt.getBytesRef();
ts.reset();
while (ts.incrementToken()) {
termAtt.fillBytesRef();
term = new Term(fieldName, BytesRef.deepCopyOf(bytes));
bq.add(new BooleanClause(new TermQuery(term), BooleanClause.Occur.SHOULD));
}
ts.end();
ts.close();
} catch (IOException ioe) {
throw new RuntimeException("Error constructing terms from index:" + ioe);
}
bq.setBoost(DOMUtils.getAttribute(e, "boost", 1.0f));
return bq;
}
@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;
}
@Override
public List<Document> customRanking(List<Query> queryList) throws Exception {
List<Document> result = new ArrayList<Document>();
Map<String, ResultRep> docMap = new LinkedHashMap<String, ResultRep>();
BooleanQuery bq = new BooleanQuery();
bq.setMinimumNumberShouldMatch(1);
Set<String> tgtset = tstSet == null ? new HashSet<String>() : tstSet;
for (String clsStr : tgtset)
bq.add(
new TermQuery(new Term(Configuration.IDX_FIELD_PKG_NAME, QueryParser.escape(clsStr))),
Occur.SHOULD);
Filter idFilter = new QueryWrapperFilter(bq);
try {
Float avg = new Float(queryList.size());
Float rank;
// BooleanQuery mainQuery;
for (Query query : queryList) {
// mainQuery = new BooleanQuery();
// mainQuery.add(query, Occur.SHOULD);
// mainQuery.add(idFilter, Occur.MUST);
result = searcher(query, idFilter);
for (int i = 0; i < result.size(); i++) {
Document doc = result.get(i);
String key = doc.get(Configuration.IDX_FIELD_METHOD_DESCRIPTION_CATCHALL);
rank = Float.parseFloat(doc.get("SCORE"));
rank = rank / avg;
if (!docMap.containsKey(key)) docMap.put(key, new ResultRep(doc, rank));
else {
ResultRep rep = docMap.get(key);
rep.setRank(rep.getRank() + rank);
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
TreeSet<ResultRep> set = new TreeSet<ResultRep>(new CustomComparator());
for (String key : docMap.keySet()) set.add(docMap.get(key));
result = new ArrayList<Document>();
Iterator<ResultRep> iter = set.descendingIterator();
ResultRep rep;
while (iter.hasNext()) {
rep = iter.next();
if (tgtset.contains(rep.getDoc().get(Configuration.IDX_FIELD_CLASS_NAME).trim()))
result.add(rep.getDoc());
}
if (result.size() > 10) result = result.subList(0, 10);
return result;
}
@Override
public Query apply(Function input, Context context) {
assert input != null;
BooleanQuery query = new BooleanQuery();
query.setMinimumNumberShouldMatch(1);
for (Symbol symbol : input.arguments()) {
query.add(process(symbol, context), BooleanClause.Occur.SHOULD);
}
return query;
}
@Override
protected Query applyArrayLiteral(Reference reference, Literal arrayLiteral, Context context)
throws IOException {
// col like ANY (['a', 'b']) --> or(like(col, 'a'), like(col, 'b'))
BooleanQuery booleanQuery = new BooleanQuery();
booleanQuery.setMinimumNumberShouldMatch(1);
for (Object value : toIterable(arrayLiteral.value())) {
booleanQuery.add(
likeQuery.toQuery(reference, value, context), BooleanClause.Occur.SHOULD);
}
return booleanQuery;
}
@Override
public void readFields(DataInput in) throws IOException {
query = new BooleanQuery(in.readBoolean());
query.setBoost(in.readFloat());
query.setMinimumNumberShouldMatch(in.readInt());
int length = in.readInt();
for (int i = 0; i < length; i++) {
BooleanClauseWritable booleanClauseWritable = new BooleanClauseWritable();
booleanClauseWritable.readFields(in);
query.add(booleanClauseWritable.getBooleanClause());
}
}
@Override
protected Query applyArrayLiteral(Reference reference, Literal arrayLiteral, Context context)
throws IOException {
// col < ANY ([1,2,3]) --> or(col<1, col<2, col<3)
BooleanQuery booleanQuery = new BooleanQuery();
booleanQuery.setMinimumNumberShouldMatch(1);
for (Object value : toIterable(arrayLiteral.value())) {
booleanQuery.add(
inverseRangeQuery.toQuery(reference, reference.valueType(), value),
BooleanClause.Occur.SHOULD);
}
return booleanQuery;
}
@Override
protected Query applyArrayReference(
Reference arrayReference, Literal literal, Context context) throws IOException {
// 1 != any ( col ) --> gt 1 or lt 1
String columnName = arrayReference.info().ident().columnIdent().fqn();
Object value = literal.value();
QueryBuilderHelper builder = QueryBuilderHelper.forType(arrayReference.valueType());
BooleanQuery query = new BooleanQuery();
query.setMinimumNumberShouldMatch(1);
query.add(
builder.rangeQuery(columnName, value, null, false, false), BooleanClause.Occur.SHOULD);
query.add(
builder.rangeQuery(columnName, null, value, false, false), BooleanClause.Occur.SHOULD);
return query;
}
public CObjList searchSubscribable(
String squery, String memid, boolean prv, boolean pub, Sort s) {
if (!prv && !pub) {
prv = true;
pub = true;
}
BooleanQuery combined = new BooleanQuery();
combined.setMinimumNumberShouldMatch(1);
Term comterm = new Term(CObj.PARAM_TYPE, CObj.COMMUNITY);
combined.add(new TermQuery(comterm), BooleanClause.Occur.MUST);
if (pub) {
Term pubterm = new Term(CObj.docString(CObj.SCOPE), CObj.SCOPE_PUBLIC);
combined.add(new TermQuery(pubterm), BooleanClause.Occur.SHOULD);
}
if (prv && memid != null) {
Term pubterm2 = new Term(CObj.docPrivate(memid), "true");
combined.add(new TermQuery(pubterm2), BooleanClause.Occur.SHOULD);
}
if (squery != null) {
Matcher m = Pattern.compile("\\S+").matcher(squery);
if (m.find()) {
StringBuilder sb = new StringBuilder();
sb.append(CObj.docPrivateText(CObj.NAME));
sb.append(":\"");
sb.append(squery);
sb.append("\" OR ");
sb.append(CObj.docPrivateText(CObj.DESCRIPTION));
sb.append(":\"");
sb.append(squery);
sb.append("\"");
return search(combined, sb.toString(), Integer.MAX_VALUE, s);
}
}
return search(combined, Integer.MAX_VALUE, s);
}
@Override
public Query parse(QueryParseContext parseContext) throws IOException, QueryParsingException {
XContentParser parser = parseContext.parser();
boolean disableCoord = false;
float boost = 1.0f;
int minimumNumberShouldMatch = -1;
List<BooleanClause> clauses = newArrayList();
String currentFieldName = null;
XContentParser.Token token;
while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
if (token == XContentParser.Token.FIELD_NAME) {
currentFieldName = parser.currentName();
} else if (token == XContentParser.Token.START_OBJECT) {
if ("must".equals(currentFieldName)) {
clauses.add(new BooleanClause(parseContext.parseInnerQuery(), BooleanClause.Occur.MUST));
} else if ("must_not".equals(currentFieldName) || "mustNot".equals(currentFieldName)) {
clauses.add(
new BooleanClause(parseContext.parseInnerQuery(), BooleanClause.Occur.MUST_NOT));
} else if ("should".equals(currentFieldName)) {
clauses.add(
new BooleanClause(parseContext.parseInnerQuery(), BooleanClause.Occur.SHOULD));
}
} else if (token == XContentParser.Token.START_ARRAY) {
if ("must".equals(currentFieldName)) {
while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
clauses.add(
new BooleanClause(parseContext.parseInnerQuery(), BooleanClause.Occur.MUST));
}
} else if ("must_not".equals(currentFieldName) || "mustNot".equals(currentFieldName)) {
while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
clauses.add(
new BooleanClause(parseContext.parseInnerQuery(), BooleanClause.Occur.MUST_NOT));
}
} else if ("should".equals(currentFieldName)) {
while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
clauses.add(
new BooleanClause(parseContext.parseInnerQuery(), BooleanClause.Occur.SHOULD));
}
}
} else if (token.isValue()) {
if ("disable_coord".equals(currentFieldName) || "disableCoord".equals(currentFieldName)) {
disableCoord = parser.booleanValue();
} else if ("minimum_number_should_match".equals(currentFieldName)
|| "minimumNumberShouldMatch".equals(currentFieldName)) {
minimumNumberShouldMatch = parser.intValue();
} else if ("boost".equals(currentFieldName)) {
boost = parser.floatValue();
}
}
}
BooleanQuery query = new BooleanQuery(disableCoord);
for (BooleanClause clause : clauses) {
query.add(clause);
}
query.setBoost(boost);
if (minimumNumberShouldMatch != -1) {
query.setMinimumNumberShouldMatch(minimumNumberShouldMatch);
}
return optimizeQuery(fixNegativeQueryIfNeeded(query));
}