Merge pull request #6582 from vespa-engine/revert-6557-revert-6553-revert-6512-henrhoi/object-structured-grouping

Revert "Revert "Revert "Added a object structure for GroupingRequest objects, accessable from…"""

1 files changed, 42 insertions, 56 deletions

diff --git a/container-search/src/test/java/com/yahoo/select/SelectTestCase.java b/container-search/src/test/java/com/yahoo/select/SelectParserTestCase.java
index 6871e26b96a..031ba386ad4 100644
--- a/container-search/src/test/java/com/yahoo/select/SelectTestCase.java
+++ b/container-search/src/test/java/com/yahoo/select/SelectParserTestCase.java
@@ -15,14 +15,14 @@ import com.yahoo.prelude.query.WeakAndItem;
 import com.yahoo.prelude.query.WordAlternativesItem;
 import com.yahoo.prelude.query.WordItem;
 import com.yahoo.search.Query;
-import com.yahoo.search.grouping.GroupingRequest;
-import com.yahoo.search.grouping.request.AllOperation;
+import com.yahoo.search.federation.ProviderConfig;
 import com.yahoo.search.query.QueryTree;
 import com.yahoo.search.query.Select;
 import com.yahoo.search.query.SelectParser;
 import com.yahoo.search.query.parser.Parsable;
 import com.yahoo.search.query.parser.ParserEnvironment;
 import com.yahoo.search.yql.VespaGroupingStep;
+import org.apache.http.client.utils.URIBuilder;
 import org.json.JSONException;
 import org.json.JSONObject;
 import org.junit.Test;
@@ -33,23 +33,24 @@ import java.util.List;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotSame;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
+
 /**
- * Tests Query.Select
+ * Specification for the conversion of Select expressions to Vespa search queries.
  *
  * @author henrhoi
- * @author bratseth
  */
-public class SelectTestCase {
+
+public class SelectParserTestCase {
 
     private final SelectParser parser = new SelectParser(new ParserEnvironment());
 
-    //------------------------------------------------------------------- "where" tests
+
+    /** WHERE TESTS */
 
     @Test
     public void test_contains() throws Exception {
@@ -135,6 +136,7 @@ public class SelectTestCase {
                 "+title:madonna -title:saint");
     }
 
+
     @Test
     public void testLessThan() throws JSONException {
         JSONObject range_json = new JSONObject();
@@ -163,6 +165,7 @@ public class SelectTestCase {
                 "price:>500");
     }
 
+
     @Test
     public void testLessThanOrEqual() throws JSONException {
         JSONObject range_json = new JSONObject();
@@ -323,6 +326,7 @@ public class SelectTestCase {
         assertEquals(3, origin.end);
     }
 
+
     @Test
     public void testSameElement() {
         assertParse("{ \"contains\": [ \"baz\", {\"sameElement\" : [ { \"contains\" : [\"f1\", \"a\"] }, { \"contains\" : [\"f2\", \"b\"] } ]} ] }",
@@ -416,7 +420,7 @@ public class SelectTestCase {
         WordItem first = (WordItem)root.getItem(0);
         WordItem second = (WordItem)root.getItem(1);
         WordItem third = (WordItem)root.getItem(2);
-        assertEquals(third, first.getConnectedItem());
+        assertTrue(first.getConnectedItem() == third);
         assertEquals(first.getConnectivity(), 7.0d, 1E-6);
         assertNull(second.getConnectedItem());
 
@@ -553,17 +557,17 @@ public class SelectTestCase {
     @Test
     public void testAffixItems() {
         assertRootClass("{ \"contains\" : { \"children\" : [\"baz\", \"colors\"], \"attributes\" : {\"suffix\": true} } }",
-                        SuffixItem.class);
+                SuffixItem.class);
 
 
         assertRootClass("{ \"contains\" : { \"children\" : [\"baz\", \"colors\"], \"attributes\" : {\"prefix\": true} } }",
-                        PrefixItem.class);
+                PrefixItem.class);
         assertRootClass("{ \"contains\" : { \"children\" : [\"baz\", \"colors\"], \"attributes\" : {\"substring\": true} } }",
-                        SubstringItem.class);
+                SubstringItem.class);
         assertParseFail("{ \"contains\" : { \"children\" : [\"baz\", \"colors\"], \"attributes\" : {\"suffix\": true, \"prefix\" : true} } }",
-                        new IllegalArgumentException("Only one of prefix, substring and suffix can be set."));
+                new IllegalArgumentException("Only one of prefix, substring and suffix can be set."));
         assertParseFail("{ \"contains\" : { \"children\" : [\"baz\", \"colors\"], \"attributes\" : {\"suffix\": true, \"substring\" : true} } }",
-                        new IllegalArgumentException("Only one of prefix, substring and suffix can be set."));
+                new IllegalArgumentException("Only one of prefix, substring and suffix can be set."));
     }
 
     @Test
@@ -637,7 +641,7 @@ public class SelectTestCase {
         checkWordAlternativesContent(alternatives);
     }
 
-    //------------------------------------------------------------------- grouping tests
+    /** GROUPING TESTS */
 
     @Test
     public void testGrouping(){
@@ -655,7 +659,9 @@ public class SelectTestCase {
         assertGrouping(expected, parseGrouping(grouping));
     }
 
-    //------------------------------------------------------------------- Other tests
+
+
+    /** OTHER TESTS */
 
     @Test
     public void testOverridingOtherQueryTree() {
@@ -663,15 +669,16 @@ public class SelectTestCase {
         assertEquals("default:query", query.getModel().getQueryTree().toString());
         assertEquals(Query.Type.ALL, query.getModel().getType());
 
-        query.getSelect().setWhereString("{\"contains\" : [\"default\", \"select\"] }");
+        query.getSelect().setWhere("{\"contains\" : [\"default\", \"select\"] }");
         assertEquals("default:select", query.getModel().getQueryTree().toString());
         assertEquals(Query.Type.SELECT, query.getModel().getType());
     }
 
+
     @Test
     public void testOverridingWhereQueryTree() {
-        Query query = new Query("?query=default:query");
-        query.getSelect().setWhereString("{\"contains\" : [\"default\", \"select\"] }");
+        Query query = new Query();
+        query.getSelect().setWhere("{\"contains\" : [\"default\", \"select\"] }");
         assertEquals("default:select", query.getModel().getQueryTree().toString());
         assertEquals(Query.Type.SELECT, query.getModel().getType());
 
@@ -681,44 +688,10 @@ public class SelectTestCase {
         assertEquals(Query.Type.ALL, query.getModel().getType());
     }
 
-    @Test
-    public void testProgrammaticAssignment() {
-        Query query = new Query();
-        query.getSelect().setGroupingString("[ { \"all\" : { \"group\" : \"time.year(a)\", \"each\" : { \"output\" : \"count()\" } } } ]");
-        assertEquals(1, query.getSelect().getGrouping().size());
-        assertEquals("all(group(time.year(a)) each(output(count())))", query.getSelect().getGrouping().get(0).getRootOperation().toString());
 
-        // Setting from string resets the grouping expression
-        query.getSelect().setGroupingString("[ { \"all\" : { \"group\" : \"time.dayofmonth(a)\", \"each\" : { \"output\" : \"count()\" } } } ]");
-        assertEquals(1, query.getSelect().getGrouping().size());
-        assertEquals("all(group(time.dayofmonth(a)) each(output(count())))", query.getSelect().getGrouping().get(0).getRootOperation().toString());
-    }
 
-    @Test
-    public void testConstructionAndClone() {
-        Query query = new Query();
-        query.getSelect().setWhereString("{\"contains\" : [\"default\", \"select\"] }");
-        query.getSelect().setGroupingString("[ { \"all\" : { \"group\" : \"time.dayofmonth(a)\", \"each\" : { \"output\" : \"count()\" } } } ]");
-        GroupingRequest secondRequest = GroupingRequest.newInstance(query);
-        assertEquals("default:select", query.getModel().getQueryTree().toString());
-        assertEquals(2, query.getSelect().getGrouping().size());
-        assertEquals("all(group(time.dayofmonth(a)) each(output(count())))", query.getSelect().getGrouping().get(0).toString());
-
-        Query clone = query.clone();
-        assertNotSame(query.getSelect(), clone.getSelect());
-        assertNotSame(query.getSelect().getGrouping(), clone.getSelect().getGrouping());
-        assertNotSame(query.getSelect().getGrouping().get(0), clone.getSelect().getGrouping().get(0));
-        assertNotSame(query.getSelect().getGrouping().get(1), clone.getSelect().getGrouping().get(1));
-        assertEquals(query.getSelect().getWhereString(), clone.getSelect().getWhereString());
-        assertEquals(query.getSelect().getGroupingString(), clone.getSelect().getGroupingString());
-        assertEquals(query.getSelect().getGrouping().get(0).toString(), clone.getSelect().getGrouping().get(0).toString());
-        assertEquals(query.getSelect().getGrouping().get(1).toString(), clone.getSelect().getGrouping().get(1).toString());
-
-
-    }
-
-    //------------------------------------------------------------------- Assert methods
 
+    /** Assert-methods */
     private void assertParse(String where, String expectedQueryTree) {
         String queryTree = parseWhere(where).toString();
         assertEquals(expectedQueryTree, queryTree);
@@ -748,10 +721,13 @@ public class SelectTestCase {
         assertEquals(expected, actual.toString());
     }
 
-    //------------------------------------------------------------------- Parse methods
+
+
+
+    /** Parse-methods*/
 
     private QueryTree parseWhere(String where) {
-        Select select = new Select(where, "", new Query());
+        Select select = new Select(where, "");
 
         return parser.parse(new Parsable().setSelect(select));
     }
@@ -761,8 +737,17 @@ public class SelectTestCase {
         return parser.getGroupingSteps(grouping);
     }
 
-    //------------------------------------------------------------------- Other methods
+    private QueryTree parse(String where, String grouping) {
+        Select select = new Select(where, grouping);
 
+        return parser.parse(new Parsable().setSelect(select));
+    }
+
+
+
+
+
+    /** Other methods */
     private WordItem getRootWord(String yqlQuery) {
         Item root = parseWhere(yqlQuery).getRoot();
         assertTrue(root instanceof WordItem);
@@ -790,4 +775,5 @@ public class SelectTestCase {
         }
     }
 
+
 }