DATASOLR-196 - Introduce connect() and notOperator() to Criteria.

connect() allows to explicitly create bracketing.
  //z:roo AND (x:foo OR y:bar)
  where(“z”).is(“roo”).connect().and(where(“x”).is(“foo”).or(“y”).is(“bar”))

notOpereator allows to wrap whole or expression parts inside a negating statement
  //z:roo OR -(x:foo OR y:bar)
  where("z").is("roo").connect().or(where("x").is("foo").or("y").is("bar").notOperator())

Author: christophstrobl

src/main/java/org/springframework/data/solr/core/QueryParserBase.java

@@ -139,8 +139,12 @@ public String createQueryStringFromNode(Node node, int position) {
 		if (position > 0) {
 			query.append(node.isOr() ? " OR " : " AND ");
 		}
+
 		if (node.hasSiblings()) {
-			if (!node.isRoot()) {
+			if (node.isNegating()) {
+				query.append("-");
+			}
+			if (!node.isRoot() || (node.isRoot() && node.isNegating())) {
 				query.append('(');
 			}
 
@@ -149,7 +153,7 @@ public String createQueryStringFromNode(Node node, int position) {
 				query.append(createQueryStringFromNode(nested, i++));
 			}
 
-			if (!node.isRoot()) {
+			if (!node.isRoot() || (node.isRoot() && node.isNegating())) {
 				query.append(')');
 			}
 		} else {

src/main/java/org/springframework/data/solr/core/query/Criteria.java

@@ -44,7 +44,6 @@ public class Criteria extends Node {
 
 	private Field field;
 	private float boost = Float.NaN;
-	private boolean negating = false;
 
 	private Set<Predicate> predicates = new LinkedHashSet<Predicate>();
 
@@ -302,10 +301,25 @@ public Criteria endsWith(Iterable<String> values) {
 	 * @return
 	 */
 	public Criteria not() {
-		this.negating = true;
+		setNegating(true);
 		return this;
 	}
 
+	/**
+	 * Explicitly wrap {@link Criteria} inside not operation.
+	 * 
+	 * @since 1.4
+	 * @return
+	 */
+	public Criteria notOperator() {
+
+		Crotch c = new Crotch();
+		c.setNegating(true);
+		c.add(this);
+
+		return c;
+	}
+
 	/**
 	 * Crates new {@link Predicate} with trailing {@code ~}
 	 * 
@@ -574,7 +588,7 @@ public Field getField() {
 	 * @return true if {@code not()} criteria
 	 */
 	public boolean isNegating() {
-		return this.negating;
+		return super.isNegating();
 	}
 
 	/**
@@ -709,6 +723,18 @@ public String toString() {
 
 	// -------- NODE STUFF ---------
 
+	/**
+	 * Explicitly connect {@link Criteria} with another one allows to create explicit bracketing.
+	 * 
+	 * @since 1.4
+	 * @return
+	 */
+	public Criteria connect() {
+		Crotch c = new Crotch();
+		c.add(this);
+		return c;
+	}
+
 	@SuppressWarnings("unchecked")
 	@Override
 	public Crotch and(Node node) {

src/main/java/org/springframework/data/solr/core/query/Crotch.java

@@ -57,10 +57,22 @@ public Crotch boost(float boost) {
 
 	@Override
 	public Crotch not() {
+
 		mostRecentSibling.not();
 		return this;
 	}
 
+	@Override
+	public Crotch notOperator() {
+
+		if (this.isRoot()) {
+			this.setNegating(true);
+		} else {
+			super.notOperator();
+		}
+		return this;
+	}
+
 	@Override
 	public Crotch endsWith(String postfix) {
 		mostRecentSibling.endsWith(postfix);

src/main/java/org/springframework/data/solr/core/query/Node.java

@@ -30,6 +30,7 @@ public abstract class Node {
 
 	private Node parent;
 	private boolean isOr = false;
+	private boolean negating = false;
 
 	protected Node() {}
 
@@ -84,6 +85,22 @@ public Collection<Criteria> getSiblings() {
 		return Collections.emptyList();
 	}
 
+	/**
+	 * @return true if {@code not()} criteria
+	 * @since 1.4
+	 */
+	public boolean isNegating() {
+		return this.negating;
+	}
+
+	/**
+	 * @param negating
+	 * @since 1.4
+	 */
+	protected void setNegating(boolean negating) {
+		this.negating = negating;
+	}
+
 	// ------ CONJUNCTIONS --------
 	/**
 	 * Combine two {@link Node}s using {@literal and}.

src/test/java/org/springframework/data/solr/core/DefaultQueryParserTests.java

@@ -1101,6 +1101,114 @@ public void testConstructGroupQueryWithMultipleQueries() {
 		Assert.assertNull(solrQuery.getParams(GroupParams.GROUP_FIELD));
 	}
 
+	/**
+	 * @see DATASOLR-196
+	 */
+	@Test
+	public void connectShouldAllowConcatinationOfCriteriaWithAndPreservingDesiredBracketing() {
+
+		Criteria part1 = Criteria.where("z").is("roo");
+		Criteria part2 = Criteria.where("x").is("foo").or("y").is("bar");
+		Criteria criteria = part1.connect().and(part2);
+
+		Assert.assertEquals("z:roo AND (x:foo OR y:bar)", queryParser.createQueryStringFromNode(criteria));
+	}
+
+	/**
+	 * @see DATASOLR-196
+	 */
+	@Test
+	public void connectShouldAllowConcatinationOfCriteriaWithAndPreservingDesiredBracketingReverse() {
+
+		Criteria part1 = Criteria.where("z").is("roo");
+		Criteria part2 = Criteria.where("x").is("foo").or("y").is("bar");
+		Criteria criteria = part2.connect().and(part1);
+
+		Assert.assertEquals("(x:foo OR y:bar) AND z:roo", queryParser.createQueryStringFromNode(criteria));
+	}
+
+	/**
+	 * @see DATASOLR-196
+	 */
+	@Test
+	public void connectShouldAllowConcatinationOfCriteriaWithOrPreservingDesiredBracketing() {
+
+		Criteria part1 = Criteria.where("z").is("roo");
+		Criteria part2 = Criteria.where("x").is("foo").or("y").is("bar");
+		Criteria criteria = part1.connect().or(part2);
+
+		Assert.assertEquals("z:roo OR (x:foo OR y:bar)", queryParser.createQueryStringFromNode(criteria));
+	}
+
+	/**
+	 * @see DATASOLR-196
+	 */
+	@Test
+	public void connectShouldAllowConcatinationOfCriteriaWithOrPreservingDesiredBracketingReverse() {
+
+		Criteria part1 = Criteria.where("z").is("roo");
+		Criteria part2 = Criteria.where("x").is("foo").or("y").is("bar");
+		Criteria criteria = part2.connect().or(part1);
+
+		Assert.assertEquals("(x:foo OR y:bar) OR z:roo", queryParser.createQueryStringFromNode(criteria));
+	}
+
+	/**
+	 * @see DATASOLR-196
+	 */
+	@Test
+	public void notOperatorShouldWrapWholeExpression() {
+
+		Criteria part1 = Criteria.where("text").startsWith("fx").or("product_code").startsWith("fx");
+		Criteria part2 = Criteria.where("text").startsWith("option").or("product_code").startsWith("option");
+		Criteria criteria = part1.connect().and(part2).notOperator();
+
+		String expected = "-((text:fx* OR product_code:fx*) AND (text:option* OR product_code:option*))";
+		Assert.assertEquals(expected, queryParser.createQueryStringFromNode(criteria));
+	}
+
+	/**
+	 * @see DATASOLR-196
+	 */
+	@Test
+	public void notOperatorShouldWrapNestedExpressionCorrectly() {
+
+		Criteria part1 = Criteria.where("z").is("roo");
+		Criteria part2 = Criteria.where("x").is("foo").or("y").is("bar").notOperator();
+
+		Criteria criteria = part1.connect().or(part2);
+
+		Assert.assertEquals("z:roo OR -(x:foo OR y:bar)", queryParser.createQueryStringFromNode(criteria));
+	}
+
+	/**
+	 * @see DATASOLR-196
+	 */
+	@Test
+	public void notOperatorShouldWrapNestedExpressionCorrectlyReverse() {
+
+		Criteria part1 = Criteria.where("z").is("roo");
+		Criteria part2 = Criteria.where("x").is("foo").or("y").is("bar").notOperator();
+
+		Criteria criteria = part2.connect().or(part1);
+
+		Assert.assertEquals("-(x:foo OR y:bar) OR z:roo", queryParser.createQueryStringFromNode(criteria));
+	}
+
+	/**
+	 * @see DATASOLR-196
+	 */
+	@Test
+	public void notOperatorShouldWrapNestedExpressionCorrectlyReverseWithDoubleNegation() {
+
+		Criteria part1 = Criteria.where("z").is("roo");
+		Criteria part2 = Criteria.where("x").is("foo").or("y").is("bar").notOperator();
+
+		Criteria criteria = part2.connect().and(part1).notOperator();
+
+		Assert.assertEquals("-(-(x:foo OR y:bar) AND z:roo)", queryParser.createQueryStringFromNode(criteria));
+	}
+
 	private void assertPivotFactingPresent(SolrQuery solrQuery, String... expected) {
 		Assert.assertArrayEquals(expected, solrQuery.getParams(FacetParams.FACET_PIVOT));
 	}