GitHub-Spring
/
spring-data-commons
mirror of https://github.com/spring-projects/spring-data-commons.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

DATACMNS-141 - Added Before and After as query parser keywords. 

The query parser now supports After, IsAfter, Before and IsBefore as keywords. Added the Is* prefix to suitable keywords as well and refactored unit tests quite a bit to ease adding new keyword tests.
pull/14/head
Oliver Gierke 14 years ago
parent
b811fa3ea8
commit
a2e5cc439e
2 changed files with 60 additions and 80 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 17
      spring-data-commons-core/src/main/java/org/springframework/data/repository/query/parser/Part.java
  2. 123
      spring-data-commons-core/src/test/java/org/springframework/data/repository/query/parser/PartTreeUnitTests.java

17
spring-data-commons-core/src/main/java/org/springframework/data/repository/query/parser/Part.java
Unescape View File

@ -173,17 +173,20 @@ public class Part {
*/ */
public static enum Type { public static enum Type {
BETWEEN(2, "Between"), IS_NOT_NULL(0, "IsNotNull", "NotNull"), IS_NULL(0, "IsNull", "Null"), LESS_THAN("LessThan"), LESS_THAN_EQUAL( BETWEEN(2, "IsBetween", "Between"), IS_NOT_NULL(0, "IsNotNull", "NotNull"), IS_NULL(0, "IsNull", "Null"), LESS_THAN(
"LessThanEqual"), GREATER_THAN("GreaterThan"), GREATER_THAN_EQUAL("GreaterThanEqual"), NOT_LIKE("NotLike"), LIKE( "IsLessThan", "LessThan"), LESS_THAN_EQUAL("IsLessThanEqual", "LessThanEqual"), GREATER_THAN("IsGreaterThan",
"Like"), STARTING_WITH("StartingWith", "StartsWith"), ENDING_WITH("EndingWith", "EndsWith"), CONTAINING( "GreaterThan"), GREATER_THAN_EQUAL("IsGreaterThanEqual", "GreaterThanEqual"), BEFORE("IsBefore", "Before"), AFTER(
"Containing", "Contains"), NOT_IN("NotIn"), IN("In"), NEAR("Near"), WITHIN("Within"), REGEX("Regex"), EXISTS(0, "IsAfter", "After"), NOT_LIKE("NotLike"), LIKE("Like"), STARTING_WITH("IsStartingWith", "StartingWith",
"Exists"), TRUE(0, "IsTrue", "True"), FALSE(0, "IsFalse", "False"), NEGATING_SIMPLE_PROPERTY("Not"), SIMPLE_PROPERTY; "StartsWith"), ENDING_WITH("IsEndingWith", "EndingWith", "EndsWith"), CONTAINING("IsContaining", "Containing",
"Contains"), NOT_IN("IsNotIn", "NotIn"), IN("IsIn", "In"), NEAR("IsNear", "Near"), WITHIN("IsWithin", "Within"), REGEX(
"MatchesRegex", "Matches", "Regex"), EXISTS(0, "Exists"), TRUE(0, "IsTrue", "True"), FALSE(0, "IsFalse",
"False"), NEGATING_SIMPLE_PROPERTY("IsNot", "Not"), SIMPLE_PROPERTY("Is", "Equals");
// Need to list them again explicitly as the order is important // Need to list them again explicitly as the order is important
// (esp. for IS_NULL, IS_NOT_NULL) // (esp. for IS_NULL, IS_NOT_NULL)
private static final List<Part.Type> ALL = Arrays.asList(IS_NOT_NULL, IS_NULL, BETWEEN, LESS_THAN, LESS_THAN_EQUAL, private static final List<Part.Type> ALL = Arrays.asList(IS_NOT_NULL, IS_NULL, BETWEEN, LESS_THAN, LESS_THAN_EQUAL,
GREATER_THAN, GREATER_THAN_EQUAL, NOT_LIKE, LIKE, STARTING_WITH, ENDING_WITH, CONTAINING, NOT_IN, IN, NEAR, GREATER_THAN, GREATER_THAN_EQUAL, BEFORE, AFTER, NOT_LIKE, LIKE, STARTING_WITH, ENDING_WITH, CONTAINING,
WITHIN, REGEX, EXISTS, TRUE, FALSE, NEGATING_SIMPLE_PROPERTY, SIMPLE_PROPERTY); NOT_IN, IN, NEAR, WITHIN, REGEX, EXISTS, TRUE, FALSE, NEGATING_SIMPLE_PROPERTY, SIMPLE_PROPERTY);
private final List<String> keywords; private final List<String> keywords;
private final int numberOfArguments; private final int numberOfArguments;

123
spring-data-commons-core/src/test/java/org/springframework/data/repository/query/parser/PartTreeUnitTests.java
Unescape View File

@ -15,12 +15,15 @@
*/ */
package org.springframework.data.repository.query.parser; package org.springframework.data.repository.query.parser;
import static java.util.Arrays.*;
import static org.hamcrest.Matchers.*; import static org.hamcrest.Matchers.*;
import static org.junit.Assert.assertThat; import static org.junit.Assert.*;
import static org.springframework.data.repository.query.parser.Part.Type.*;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Arrays; import java.util.Arrays;
import java.util.Collection; import java.util.Collection;
import java.util.Date;
import java.util.Iterator; import java.util.Iterator;
import java.util.List; import java.util.List;
@ -133,17 +136,12 @@ public class PartTreeUnitTests {
@Test @Test
public void parsesNearCorrectly() { public void parsesNearCorrectly() {
PartTree tree = partTree("findByLocationNear"); assertType(asList("locationNear"), NEAR, "location");
for (Part part : tree.getParts()) {
assertThat(part.getType(), is(Type.NEAR));
assertThat(part.getProperty(), is(newProperty("location")));
}
} }
@Test @Test
public void supportToStringWithoutSortOrder() throws Exception { public void supportToStringWithoutSortOrder() throws Exception {
PartTree tree = partTree("firstname"); assertType(asList("firstname"), SIMPLE_PROPERTY, "firstname");
assertThat(tree.toString(), is(equalTo("firstname SIMPLE_PROPERTY")));
} }
@Test @Test
@ -192,12 +190,7 @@ public class PartTreeUnitTests {
*/ */
@Test @Test
public void parsesLessThanEqualCorrectly() { public void parsesLessThanEqualCorrectly() {
assertType(Arrays.asList("lastnameLessThanEqual", "lastnameIsLessThanEqual"), LESS_THAN_EQUAL, "lastname");
PartTree tree = partTree("findByLastnameLessThanEqual");
for (Part part : tree.getParts()) {
assertThat(part.getType(), is(Type.LESS_THAN_EQUAL));
assertThat(part.getProperty(), is(newProperty("lastname")));
}
} }
/** /**
@ -205,12 +198,7 @@ public class PartTreeUnitTests {
*/ */
@Test @Test
public void parsesGreaterThanEqualCorrectly() { public void parsesGreaterThanEqualCorrectly() {
assertType(Arrays.asList("lastnameGreaterThanEqual", "lastnameIsGreaterThanEqual"), GREATER_THAN_EQUAL, "lastname");
PartTree tree = partTree("findByLastnameGreaterThanEqual");
for (Part part : tree.getParts()) {
assertThat(part.getType(), is(Type.GREATER_THAN_EQUAL));
assertThat(part.getProperty(), is(newProperty("lastname")));
}
} }
@Test @Test
@ -239,12 +227,7 @@ public class PartTreeUnitTests {
*/ */
@Test @Test
public void parsesExistsKeywordCorrectly() { public void parsesExistsKeywordCorrectly() {
assertType(asList("lastnameExists"), EXISTS, "lastname", 0, false);
Part part = part("lastnameExists");
assertThat(part.getType(), is(Type.EXISTS));
assertThat(part.getProperty().toDotPath(), is("lastname"));
assertThat(part.getNumberOfArguments(), is(0));
assertThat(part.getParameterRequired(), is(false));
} }
/** /**
@ -252,12 +235,7 @@ public class PartTreeUnitTests {
*/ */
@Test @Test
public void parsesRegexKeywordCorrectly() { public void parsesRegexKeywordCorrectly() {
assertType(asList("lastnameRegex", "lastnameMatchesRegex", "lastnameMatches"), REGEX, "lastname");
Part part = part("lastnameRegex");
assertThat(part.getType(), is(Type.REGEX));
assertThat(part.getProperty().toDotPath(), is("lastname"));
assertThat(part.getNumberOfArguments(), is(1));
assertThat(part.getParameterRequired(), is(true));
} }
/** /**
@ -265,14 +243,7 @@ public class PartTreeUnitTests {
*/ */
@Test @Test
public void parsesTrueKeywordCorrectly() { public void parsesTrueKeywordCorrectly() {
assertType(asList("activeTrue", "activeIsTrue"), TRUE, "active", 0, false);
for (String source : Arrays.asList("activeTrue", "activeIsTrue")) {
Part part = part(source);
assertThat(part.getType(), is(Type.TRUE));
assertThat(part.getProperty().toDotPath(), is("active"));
assertThat(part.getNumberOfArguments(), is(0));
assertThat(part.getParameterRequired(), is(false));
}
} }
/** /**
@ -280,14 +251,7 @@ public class PartTreeUnitTests {
*/ */
@Test @Test
public void parsesFalseKeywordCorrectly() { public void parsesFalseKeywordCorrectly() {
assertType(asList("activeFalse", "activeIsFalse"), FALSE, "active", 0, false);
for (String source : Arrays.asList("activeFalse", "activeIsFalse")) {
Part part = part(source);
assertThat(part.getType(), is(Type.FALSE));
assertThat(part.getProperty().toDotPath(), is("active"));
assertThat(part.getNumberOfArguments(), is(0));
assertThat(part.getParameterRequired(), is(false));
}
} }
/** /**
@ -295,14 +259,8 @@ public class PartTreeUnitTests {
*/ */
@Test @Test
public void parsesStartingWithKeywordCorrectly() { public void parsesStartingWithKeywordCorrectly() {
assertType(asList("firstnameStartsWith", "firstnameStartingWith", "firstnameIsStartingWith"), STARTING_WITH,
for (String source : Arrays.asList("firstnameStartsWith", "firstnameStartingWith")) { "firstname");
Part part = part(source);
assertThat(part.getType(), is(Type.STARTING_WITH));
assertThat(part.getProperty().toDotPath(), is("firstname"));
assertThat(part.getNumberOfArguments(), is(1));
assertThat(part.getParameterRequired(), is(true));
}
} }
/** /**
@ -310,14 +268,7 @@ public class PartTreeUnitTests {
*/ */
@Test @Test
public void parsesEndingWithKeywordCorrectly() { public void parsesEndingWithKeywordCorrectly() {
assertType(asList("firstnameEndsWith", "firstnameEndingWith", "firstnameIsEndingWith"), ENDING_WITH, "firstname");
for (String source : Arrays.asList("firstnameEndsWith", "firstnameEndingWith")) {
Part part = part(source);
assertThat(part.getType(), is(Type.ENDING_WITH));
assertThat(part.getProperty().toDotPath(), is("firstname"));
assertThat(part.getNumberOfArguments(), is(1));
assertThat(part.getParameterRequired(), is(true));
}
} }
/** /**
@ -325,25 +276,50 @@ public class PartTreeUnitTests {
*/ */
@Test @Test
public void parsesContainingKeywordCorrectly() { public void parsesContainingKeywordCorrectly() {
assertType(asList("firstnameIsContaining", "firstnameContains", "firstnameContaining"), CONTAINING, "firstname");
}
/**
* @see DATACMNS-141
*/
@Test
public void parsesAfterKeywordCorrectly() {
assertType(asList("birthdayAfter", "birthdayIsAfter"), Type.AFTER, "birthday");
}
/**
* @see DATACMNS-141
*/
@Test
public void parsesBeforeKeywordCorrectly() {
assertType(Arrays.asList("birthdayBefore", "birthdayIsBefore"), Type.BEFORE, "birthday");
}
private static void assertType(Iterable<String> sources, Type type, String property) {
assertType(sources, type, property, 1, true);
}
private static void assertType(Iterable<String> sources, Type type, String property, int numberOfArguments,
boolean parameterRequired) {
for (String source : Arrays.asList("firstnameContains", "firstnameContaining")) { for (String source : sources) {
Part part = part(source); Part part = part(source);
assertThat(part.getType(), is(Type.CONTAINING)); assertThat(part.getType(), is(type));
assertThat(part.getProperty().toDotPath(), is("firstname")); assertThat(part.getProperty(), is(newProperty(property)));
assertThat(part.getNumberOfArguments(), is(1)); assertThat(part.getNumberOfArguments(), is(numberOfArguments));
assertThat(part.getParameterRequired(), is(true)); assertThat(part.getParameterRequired(), is(parameterRequired));
} }
} }
private PartTree partTree(String source) { private static PartTree partTree(String source) {
return new PartTree(source, User.class); return new PartTree(source, User.class);
} }
private Part part(String part) { private static Part part(String part) {
return new Part(part, User.class); return new Part(part, User.class);
} }
private Part[] parts(String... part) { private static Part[] parts(String... part) {
Part[] parts = new Part[part.length]; Part[] parts = new Part[part.length];
for (int i = 0; i < parts.length; i++) { for (int i = 0; i < parts.length; i++) {
parts[i] = part(part[i]); parts[i] = part(part[i]);
@ -351,7 +327,7 @@ public class PartTreeUnitTests {
return parts; return parts;
} }
private PropertyPath newProperty(String name) { private static PropertyPath newProperty(String name) {
return PropertyPath.from(name, User.class); return PropertyPath.from(name, User.class);
} }
@ -384,5 +360,6 @@ public class PartTreeUnitTests {
String lastname; String lastname;
double[] location; double[] location;
boolean active; boolean active;
Date birthday;
} }
} }

Write Preview
Loading…
Cancel
Save