@Override protected void addClause(final NodeBooleanQuery topLevel, final Term term, final int docFreq, final float boost /*ignored*/, final TermContext states) { topLevel.add(new NodeTermQuery(term, states), Occur.SHOULD); }
@Override public void extractTerms(final Set<Term> terms) { terms.add(this.getTerm()); }
@Override protected void addClause(final NodeBooleanQuery topLevel, final Term term, final int docCount, final float boost, final TermContext states) { final NodeTermQuery tq = new NodeTermQuery(term, states); tq.setBoost(boost); topLevel.add(tq, Occur.SHOULD); }
/** * Prints a user-readable version of this query. * <p> * The term is wrapped in simple quotes, so that any special characters it * may contains are disabled. See ProtectedQueryNode in siren-qparser. */ @Override public String toString(final String field) { final StringBuilder builder = new StringBuilder(); final CharSequence text = term.text(); if (text.length() != 0) { builder.append("'").append(text).append("'"); } builder.append(ToStringUtils.boost(this.getBoost())); return this.wrapToStringWithDatatype(builder).toString(); }
private NodeTermQueryBuilder(final String fieldName, final String term) { final Term t = new Term(fieldName, term); ntq = new NodeTermQuery(t); // Add default datatype ntq.setDatatype(XSDDatatype.XSD_STRING); }
@Test public void testSetLevelConstraint() { final NodeTermQuery ntq = new NodeTermQuery(new Term("field", "value")); final NodeBooleanQuery bq = new NodeBooleanQuery(); bq.add(ntq, Occur.MUST); bq.setLevelConstraint(3); assertEquals(3, bq.getLevelConstraint()); // node queries in node boolean clauses must have been updated assertEquals(3, ntq.getLevelConstraint()); final NodeTermQuery ntq2 = new NodeTermQuery(new Term("field", "value")); bq.add(ntq2, Occur.MUST); // new clause must have been updated assertEquals(3, ntq2.getLevelConstraint()); }
@Override public NodeQueryBuilder setDatatype(final String datatype) { ntq.setDatatype(datatype); return this; }
/** Returns true iff <code>o</code> is equal to this. */ @Override public boolean equals(final Object o) { if (!(o instanceof NodeTermQuery)) return false; final NodeTermQuery other = (NodeTermQuery) o; return (this.getBoost() == other.getBoost()) && this.term.equals(other.term) && this.levelConstraint == other.levelConstraint && this.lowerBound == other.lowerBound && this.upperBound == other.upperBound && StringUtils.equals(this.datatype, other.datatype); }
@Override public Scorer scorer(final AtomicReaderContext context, final Bits acceptDocs) throws IOException { assert termStates.topReaderContext == ReaderUtil.getTopLevelContext(context) : "The top-reader used to create " + "Weight (" + termStates.topReaderContext + ") is not the same as the current reader's top-reader (" + ReaderUtil.getTopLevelContext(context); final TermsEnum termsEnum = this.getTermsEnum(context); if (termsEnum == null) { return null; } final DocsAndPositionsEnum docsEnum = termsEnum.docsAndPositions(acceptDocs, null); final DocsNodesAndPositionsEnum sirenDocsEnum = NodeTermQuery.this.getDocsNodesAndPositionsEnum(docsEnum); return new NodeTermScorer(this, sirenDocsEnum, similarity.simScorer(stats, context)); }
@Override public Query build(final QueryNode queryNode) throws QueryNodeException { if (conf.has(ConciseKeywordQueryConfigHandler.ConciseKeywordConfigurationKeys.ATTRIBUTE)) { final String attribute = conf.get(ConciseKeywordQueryConfigHandler.ConciseKeywordConfigurationKeys.ATTRIBUTE); final String field = conf.get(ConciseKeywordQueryConfigHandler.ConciseKeywordConfigurationKeys.FIELD); // create the node term query NodeTermQuery ntq = new NodeTermQuery(new Term(field, ConciseNodeBuilderUtil.prepend(builder, attribute, ""))); // assign the datatype. We must always have a datatype assigned. String datatype = DatatypeProcessor.getDefaultDatatype(this.conf); ntq.setDatatype(datatype); return ntq; } else { return new NodeBooleanQuery(); } }
/** Returns a hash code value for this object. */ @Override public int hashCode() { return Float.floatToIntBits(this.getBoost()) ^ term.hashCode() ^ levelConstraint ^ upperBound ^ lowerBound; }
@Override protected void addClause(final NodeBooleanQuery topLevel, final Term term, final int docFreq, final float boost, final TermContext states) { final NodeQuery q = new NodeConstantScoreQuery(new NodeTermQuery(term, states)); q.setBoost(boost); topLevel.add(q, NodeBooleanClause.Occur.SHOULD); } }
@Override protected void addClause(final NodeBooleanQuery topLevel, final Term term, final int docCount, final float boost, final TermContext states) { final NodeTermQuery tq = new NodeTermQuery(term, states); tq.setBoost(boost); topLevel.add(tq, Occur.SHOULD); }
public NodeQuery build(QueryNode queryNode) throws QueryNodeException { final FieldQueryNode fieldNode = (FieldQueryNode) queryNode; // if it is tagged as a span query if (fieldNode.getTag(QueryTypeProcessor.QUERYTYPE_TAG) == QueryTypeProcessor.SPAN_QUERYTYPE) { // create the term span query TermSpanQuery tsq = new TermSpanQuery(new Term(fieldNode.getFieldAsString(), fieldNode.getTextAsString())); // assign the datatype. We must always have a datatype assigned. tsq.setDatatype((String) queryNode.getTag(DatatypeQueryNode.DATATYPE_TAGID)); return tsq; } else { // create the node term query NodeTermQuery ntq = new NodeTermQuery(new Term(fieldNode.getFieldAsString(), fieldNode.getTextAsString())); // assign the datatype. We must always have a datatype assigned. ntq.setDatatype((String) queryNode.getTag(DatatypeQueryNode.DATATYPE_TAGID)); return ntq; } }
private boolean isMatching(JsonNode jsonNode, Query termOrRangeQuery, String fieldName) throws ProjectionException { if (termOrRangeQuery instanceof NodeTermQuery || termOrRangeQuery instanceof NodePrefixQuery) { Pattern termPat = null; if (termOrRangeQuery instanceof NodeTermQuery) { termPat = Pattern.compile(((NodeTermQuery) termOrRangeQuery).getTerm().text(), Pattern.CASE_INSENSITIVE); } else if (termOrRangeQuery instanceof NodePrefixQuery) { termPat = Pattern.compile(((NodePrefixQuery) termOrRangeQuery).getPrefix().text() + ".*", Pattern.CASE_INSENSITIVE); } if (jsonNode.isObject()) { if (termPat.matcher(jsonNode.get(fieldName).asText()).matches()) { return true; } } else { if (termPat.matcher(jsonNode.asText()).matches()) { return true; } } return false; } else if (termOrRangeQuery instanceof NodeNumericRangeQuery<?>) { return evaluateNumericRangeQuery(jsonNode, (NodeNumericRangeQuery<?>) termOrRangeQuery); } return false; }
public NodeTermWeight(final IndexSearcher searcher, final TermContext termStates) throws IOException { assert termStates != null : "TermContext must not be null"; this.termStates = termStates; this.similarity = searcher.getSimilarity(); this.stats = similarity.computeWeight( NodeTermQuery.this.getBoost(), searcher.collectionStatistics(term.field()), searcher.termStatistics(term, termStates)); }
@Test public void testEquality() throws Exception { final NodeBooleanQuery bq1 = new NodeBooleanQuery(); bq1.add(new NodeTermQuery(new Term("field", "value1")), NodeBooleanClause.Occur.SHOULD); bq1.add(new NodeTermQuery(new Term("field", "value2")), NodeBooleanClause.Occur.SHOULD); final NodeBooleanQuery bq2 = new NodeBooleanQuery(); bq2.add(new NodeTermQuery(new Term("field", "value1")), NodeBooleanClause.Occur.SHOULD); bq2.add(new NodeTermQuery(new Term("field", "value2")), NodeBooleanClause.Occur.SHOULD); assertEquals(bq2, bq1); }
@Override public Query rewrite(final IndexReader reader) throws IOException { if (terms.isEmpty()) { final NodeBooleanQuery bq = new NodeBooleanQuery(); bq.setBoost(this.getBoost()); return bq; } else if (terms.size() == 1) { final NodeTermQuery tq = new NodeTermQuery(terms.get(0)); tq.setBoost(this.getBoost()); return tq; } else { return super.rewrite(reader); } }
public NodePhraseQuery build(final QueryNode queryNode) throws QueryNodeException { final TokenizedPhraseQueryNode phraseNode = (TokenizedPhraseQueryNode) queryNode; final NodePhraseQuery phraseQuery = new NodePhraseQuery(); final List<QueryNode> children = phraseNode.getChildren(); if (children != null) { for (QueryNode child : children) { // the query node should always be a FieldQueryNode assert child instanceof FieldQueryNode; final FieldQueryNode termNode = (FieldQueryNode) child; final NodeTermQuery termQuery = (NodeTermQuery) child.getTag(QueryTreeBuilder.QUERY_TREE_BUILDER_TAGID); phraseQuery.add(termQuery.getTerm(), termNode.getPositionIncrement()); } } // assign the datatype. We must always have a datatype assigned. phraseQuery.setDatatype((String) queryNode.getTag(DatatypeQueryNode.DATATYPE_TAGID)); return phraseQuery; }
@Test public void testSetAncestor() { final NodeTermQuery ntq = new NodeTermQuery(new Term("field", "value")); final NodeBooleanQuery bq1 = new NodeBooleanQuery(); bq1.add(ntq, Occur.MUST); final NodeBooleanQuery bq2 = new NodeBooleanQuery(); bq1.setAncestorPointer(bq2); assertSame(bq2, bq1.ancestor); // node queries in node boolean clauses must have been updated assertSame(bq2, ntq.ancestor); final NodeTermQuery ntq2 = new NodeTermQuery(new Term("field", "value")); bq1.add(ntq2, Occur.MUST); // new clause must have been updated assertSame(bq2, ntq2.ancestor); }