From ceb6f44366553e2ffa340a55ac1db531743a8d07 Mon Sep 17 00:00:00 2001 From: Jon Bratseth Date: Fri, 19 Oct 2018 11:23:24 +0200 Subject: Nonfunctional changes only --- .../java/com/yahoo/prelude/query/TaggableItem.java | 23 +++++----- .../main/java/com/yahoo/search/yql/YqlParser.java | 41 +++++++++--------- .../com/yahoo/search/yql/ResegmentingTestCase.java | 3 +- .../com/yahoo/search/yql/YqlParserTestCase.java | 49 +++++++++++----------- 4 files changed, 57 insertions(+), 59 deletions(-) (limited to 'container-search') diff --git a/container-search/src/main/java/com/yahoo/prelude/query/TaggableItem.java b/container-search/src/main/java/com/yahoo/prelude/query/TaggableItem.java index 4e9d3d11cc5..03e85fa3260 100644 --- a/container-search/src/main/java/com/yahoo/prelude/query/TaggableItem.java +++ b/container-search/src/main/java/com/yahoo/prelude/query/TaggableItem.java @@ -6,13 +6,13 @@ package com.yahoo.prelude.query; * An interface used for anything which may be addressed using an external, * unique ID in the query tree in the backend. * - * @author Steinar Knutsen + * @author Steinar Knutsen */ public interface TaggableItem { - public int getUniqueID(); - public void setUniqueID(int id); - public boolean hasUniqueID(); + int getUniqueID(); + void setUniqueID(int id); + boolean hasUniqueID(); /** * Set the connectivity to another term in the same query tree. @@ -30,9 +30,9 @@ public interface TaggableItem { * @param connectivity a value between 0 (none) and 1 (maximal), defining the connectivity between this and the * argument item. The default connectivity is 0.1. */ - public void setConnectivity(Item item, double connectivity); - public Item getConnectedItem(); - public double getConnectivity(); + void setConnectivity(Item item, double connectivity); + Item getConnectedItem(); + double getConnectivity(); /** @@ -41,8 +41,9 @@ public interface TaggableItem { * This influences ranking features which take term significance into account and overrides the default * partial corpus based term significance computation happening in the backend. */ - public void setSignificance(double significance); - public boolean hasExplicitSignificance(); - public void setExplicitSignificance(boolean significance); - public double getSignificance(); + void setSignificance(double significance); + boolean hasExplicitSignificance(); + void setExplicitSignificance(boolean significance); + double getSignificance(); + } diff --git a/container-search/src/main/java/com/yahoo/search/yql/YqlParser.java b/container-search/src/main/java/com/yahoo/search/yql/YqlParser.java index e0e9042e1a3..ee288de4e88 100644 --- a/container-search/src/main/java/com/yahoo/search/yql/YqlParser.java +++ b/container-search/src/main/java/com/yahoo/search/yql/YqlParser.java @@ -1310,22 +1310,18 @@ public class YqlParser implements Parser { wordData = normalizer.normalize(wordData); } boolean fromQuery = getAnnotation(ast, IMPLICIT_TRANSFORMS, - Boolean.class, Boolean.TRUE, IMPLICIT_TRANSFORMS_DESCRIPTION); - boolean prefixMatch = getAnnotation(ast, PREFIX, Boolean.class, - Boolean.FALSE, - "setting for whether to use prefix match of input data"); - boolean suffixMatch = getAnnotation(ast, SUFFIX, Boolean.class, - Boolean.FALSE, - "setting for whether to use suffix match of input data"); - boolean substrMatch = getAnnotation(ast, SUBSTRING, Boolean.class, - Boolean.FALSE, - "setting for whether to use substring match of input data"); - Preconditions.checkArgument((prefixMatch ? 1 : 0) - + (substrMatch ? 1 : 0) + (suffixMatch ? 1 : 0) < 2, - "Only one of prefix, substring and suffix can be set."); - @NonNull - final TaggableItem wordItem; + Boolean.class, Boolean.TRUE, IMPLICIT_TRANSFORMS_DESCRIPTION); + boolean prefixMatch = getAnnotation(ast, PREFIX, Boolean.class, Boolean.FALSE, + "setting for whether to use prefix match of input data"); + boolean suffixMatch = getAnnotation(ast, SUFFIX, Boolean.class, Boolean.FALSE, + "setting for whether to use suffix match of input data"); + boolean substrMatch = getAnnotation(ast, SUBSTRING, Boolean.class, Boolean.FALSE, + "setting for whether to use substring match of input data"); + Preconditions.checkArgument((prefixMatch ? 1 : 0) + + (substrMatch ? 1 : 0) + (suffixMatch ? 1 : 0) < 2, + "Only one of prefix, substring and suffix can be set."); + TaggableItem wordItem; if (exactMatch) { wordItem = new ExactStringItem(wordData, fromQuery); } else if (prefixMatch) { @@ -1363,7 +1359,7 @@ public class YqlParser implements Parser { @SuppressWarnings({"deprecation"}) private boolean shouldResegmentWord(String field, boolean fromQuery) { - return resegment && fromQuery && ! indexFactsSession.getIndex(field).isAttribute(); + return resegment && fromQuery && ! indexFactsSession.getIndex(field).isAttribute(); } @NonNull @@ -1404,8 +1400,7 @@ public class YqlParser implements Parser { return parent == EquivItem.class; } - private void prepareWord(String field, OperatorNode ast, boolean fromQuery, - WordItem wordItem) { + private void prepareWord(String field, OperatorNode ast, boolean fromQuery, WordItem wordItem) { wordItem.setIndexName(field); wordStyleSettings(ast, wordItem); if (shouldResegmentWord(field, fromQuery)) { @@ -1421,10 +1416,12 @@ public class YqlParser implements Parser { { Map connectivity = getAnnotation(ast, CONNECTIVITY, Map.class, null, "connectivity settings"); if (connectivity != null) { - connectedItems.add(new ConnectedItem(out, getMapValue( - CONNECTIVITY, connectivity, CONNECTION_ID, - Integer.class), getMapValue(CONNECTIVITY, connectivity, - CONNECTION_WEIGHT, Number.class).doubleValue())); + connectedItems.add(new ConnectedItem(out, + getMapValue(CONNECTIVITY, connectivity, CONNECTION_ID, + Integer.class), getMapValue(CONNECTIVITY, + connectivity, + CONNECTION_WEIGHT, + Number.class).doubleValue())); } Number significance = getAnnotation(ast, SIGNIFICANCE, Number.class, null, "term significance"); if (significance != null) { diff --git a/container-search/src/test/java/com/yahoo/search/yql/ResegmentingTestCase.java b/container-search/src/test/java/com/yahoo/search/yql/ResegmentingTestCase.java index 1bed8ff2233..340fbf7342b 100644 --- a/container-search/src/test/java/com/yahoo/search/yql/ResegmentingTestCase.java +++ b/container-search/src/test/java/com/yahoo/search/yql/ResegmentingTestCase.java @@ -14,9 +14,10 @@ import com.yahoo.search.query.parser.ParserEnvironment; * Check rules for resegmenting words in YQL+ when segmenter is deemed * incompatible. The class under testing is {@link YqlParser}. * - * @author Steinar Knutsen + * @author Steinar Knutsen */ public class ResegmentingTestCase { + private YqlParser parser; @Before diff --git a/container-search/src/test/java/com/yahoo/search/yql/YqlParserTestCase.java b/container-search/src/test/java/com/yahoo/search/yql/YqlParserTestCase.java index e2325e52f63..b8ea1fd4f4b 100644 --- a/container-search/src/test/java/com/yahoo/search/yql/YqlParserTestCase.java +++ b/container-search/src/test/java/com/yahoo/search/yql/YqlParserTestCase.java @@ -55,15 +55,15 @@ import static org.junit.Assert.fail; /** * Specification for the conversion of YQL+ expressions to Vespa search queries. * - * @author steinar - * @author stiankri + * @author Steinar Knutsen + * @author Stian Kristoffersen */ public class YqlParserTestCase { private final YqlParser parser = new YqlParser(new ParserEnvironment()); @Test - public void requireThatDefaultsAreSane() { + public void testParserDefaults() { assertTrue(parser.isQueryParser()); assertNull(parser.getDocTypes()); } @@ -76,7 +76,7 @@ public class YqlParserTestCase { } @Test - public void requireThatGroupingStepCanBeParsed() { + public void testGroupingStep() { assertParse("select foo from bar where baz contains 'cox';", "baz:cox"); assertEquals("[]", @@ -98,7 +98,7 @@ public class YqlParserTestCase { } @Test - public void requireThatGroupingContinuationCanBeParsed() { + public void testGroupingContinuation() { assertParse("select foo from bar where baz contains 'cox' " + "| [{ 'continuations': ['BCBCBCBEBG', 'BCBKCBACBKCCK'] }]all(group(a) each(output(count())));", "baz:cox"); @@ -770,9 +770,8 @@ public class YqlParserTestCase { @Test public void testNegativeHitLimit() { - assertParse( - "select * from sources * where [{\"hitLimit\": -38}]range(foo, 0, 1);", - "foo:[0;1;-38]"); + assertParse("select * from sources * where [{\"hitLimit\": -38}]range(foo, 0, 1);", + "foo:[0;1;-38]"); } @Test @@ -830,26 +829,26 @@ public class YqlParserTestCase { @Test public void testMoreInheritedAnnotations() { - final String yqlQuery = "select * from sources * where " - + "([{\"ranked\": false}](foo contains \"a\" " - + "and ([{\"ranked\": true}](bar contains \"b\" " - + "or ([{\"ranked\": false}](foo contains \"c\" " - + "and foo contains ([{\"ranked\": true}]\"d\")))))));"; + String yqlQuery = "select * from sources * where " + + "([{\"ranked\": false}](foo contains \"a\" " + + "and ([{\"ranked\": true}](bar contains \"b\" " + + "or ([{\"ranked\": false}](foo contains \"c\" " + + "and foo contains ([{\"ranked\": true}]\"d\")))))));"; QueryTree x = parse(yqlQuery); List terms = QueryTree.getPositiveTerms(x); assertEquals(4, terms.size()); for (IndexedItem term : terms) { switch (term.getIndexedString()) { - case "a": - case "c": - assertFalse(((Item) term).isRanked()); - break; - case "b": - case "d": - assertTrue(((Item) term).isRanked()); - break; - default: - fail(); + case "a": + case "c": + assertFalse(((Item) term).isRanked()); + break; + case "b": + case "d": + assertTrue(((Item) term).isRanked()); + break; + default: + fail(); } } } @@ -921,8 +920,8 @@ public class YqlParserTestCase { private void checkWordAlternativesContent(WordAlternativesItem alternatives) { boolean seenTree = false; boolean seenForest = false; - final String forest = "trees"; - final String tree = "tree"; + String forest = "trees"; + String tree = "tree"; assertEquals(2, alternatives.getAlternatives().size()); for (WordAlternativesItem.Alternative alternative : alternatives.getAlternatives()) { if (tree.equals(alternative.word)) { -- cgit v1.2.3