Spring/spring-data-couchbase
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

DATACOUCH-137 - queryDerivation for N1QL annotated methods.

Browse Source 
Abstracted the N1QL-based variants in AbstractN1qlBasedQuery. This implementation doesn't recognize QueryParams or QueryPlan anymore in the method parameters so that the method signatures are not store-dependent.

Added query derivation from PartTree to N1QL query, using N1qlQueryCreator.

Unit tested the mapping between a Part.Type and the corresponding N1QL Expression.
This commit is contained in:
Simon Baslé
2015-07-07 19:41:27 +02:00
parent 9deaf6b480
commit c29727595c
12 changed files with 947 additions and 109 deletions
Download Patch File Download Diff File Expand all files Collapse all files

83
src/test/java/org/springframework/data/couchbase/repository/query/AbstractN1qlBasedQueryTest.java
View File

@@ -4,68 +4,28 @@ import static com.couchbase.client.java.query.Select.select;
import static org.junit.Assert.*;
import static org.mockito.Mockito.*;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.TimeUnit;
import com.couchbase.client.java.document.json.JsonArray;
import com.couchbase.client.java.document.json.JsonObject;
import com.couchbase.client.java.query.ParametrizedQuery;
import com.couchbase.client.java.query.PreparedQuery;
import com.couchbase.client.java.query.Query;
import com.couchbase.client.java.query.QueryParams;
import com.couchbase.client.java.query.QueryPlan;
import com.couchbase.client.java.query.Select;
import com.couchbase.client.java.query.SimpleQuery;
import com.couchbase.client.java.query.Statement;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.mockito.Mockito;
import org.springframework.data.couchbase.UnitTestApplicationConfig;
import org.springframework.data.couchbase.core.mapping.CouchbasePersistentEntity;
import org.springframework.data.couchbase.core.mapping.CouchbasePersistentProperty;
import org.springframework.data.domain.Page;
import org.springframework.data.mapping.context.MappingContext;
import org.springframework.data.repository.core.RepositoryMetadata;
import org.springframework.data.repository.query.Parameters;
import org.springframework.data.repository.query.QueryMethod;
import org.springframework.data.util.ReflectionUtils;
public class AbstractN1qlBasedQueryTest {
@Test
public void testQueryPlanShouldProducePreparedQuery() throws Exception {
Statement st = select("*");
QueryPlan plan = new QueryPlan(JsonObject.create());
List<Object> params = new ArrayList<Object>(2);
params.add("test");
params.add(plan);
Query query = AbstractN1qlBasedQuery.buildQuery(st, params.iterator());
JsonObject queryObject = query.n1ql();
assertTrue(query instanceof PreparedQuery);
assertEquals(plan, query.statement());
assertNull(query.params());
assertNotNull(queryObject.get("args"));
assertEquals(1, queryObject.getArray("args").size());
assertEquals("test", queryObject.getArray("args").getString(0));
params.add(QueryParams.build());
query = AbstractN1qlBasedQuery.buildQuery(st, params.iterator());
assertNotNull(query.params());
}
@Test
public void testEmptyArgumentsShouldProduceSimpleQuery() throws Exception {
Statement st = select("*");
List<Object> params = Collections.emptyList();
Query query = AbstractN1qlBasedQuery.buildQuery(st, params.iterator());
Query query = AbstractN1qlBasedQuery.buildQuery(st, JsonArray.empty());
JsonObject queryObject = query.n1ql();
assertTrue(query instanceof SimpleQuery);
assertEquals(st.toString(), query.statement().toString());
assertNull(query.params());
@@ -73,53 +33,36 @@ public class AbstractN1qlBasedQueryTest {
}
@Test
public void testOnlyQueryParamsShouldProduceSimpleQuery() {
Statement st = select("*");
QueryParams queryParams = QueryParams.build().scanWait(1, TimeUnit.DAYS);
List<Object> params = new ArrayList<Object>(1);
params.add(queryParams);
Query query = AbstractN1qlBasedQuery.buildQuery(st, params.iterator());
JsonObject queryObject = query.n1ql();
assertTrue(query instanceof SimpleQuery);
assertEquals(st.toString(), query.statement().toString());
assertEquals(queryParams, query.params());
assertFalse(queryObject.containsKey("args"));
}
@Test
public void testSimpleArgumentsShouldProduceParametrizedQuery() throws Exception {
public void testSimpleArgumentShouldProduceParametrizedQuery() throws Exception {
Statement st = select("*");
List<Object> params = new ArrayList<Object>(2);
params.add(123L);
params.add("test");
Query query = AbstractN1qlBasedQuery.buildQuery(st, params.iterator());
JsonArray placeholderValues = JsonArray.from(params);
Query query = AbstractN1qlBasedQuery.buildQuery(st, placeholderValues);
JsonObject queryObject = query.n1ql();
assertTrue(query instanceof ParametrizedQuery);
assertEquals(st.toString(), query.statement().toString());
assertNull(query.params());
assertTrue(queryObject.containsKey("args"));
JsonArray args = queryObject.getArray("args");
assertEquals(2, args.size());
assertEquals(123L, args.get(0));
assertEquals("test", args.get(1));
assertEquals(1, args.size());
assertEquals("test", args.get(0));
}
@Test
public void testSimpleArgumentsAndQueryParamsShouldProduceParametrizedQuery() throws Exception {
public void testMultipleArgumentsShouldProduceParametrizedQuery() throws Exception {
Statement st = select("*");
QueryParams queryParams = QueryParams.build().withContextId("toto");
List<Object> params = new ArrayList<Object>(2);
params.add(123L);
params.add(queryParams);
params.add("test");
Query query = AbstractN1qlBasedQuery.buildQuery(st, params.iterator());
JsonArray placeholderValues = JsonArray.from(params);
Query query = AbstractN1qlBasedQuery.buildQuery(st, placeholderValues);
JsonObject queryObject = query.n1ql();
assertTrue(query instanceof ParametrizedQuery);
assertEquals(st.toString(), query.statement().toString());
assertEquals(queryParams, query.params());
assertNull(query.params());
assertTrue(queryObject.containsKey("args"));
JsonArray args = queryObject.getArray("args");
assertEquals(2, args.size());

489
src/test/java/org/springframework/data/couchbase/repository/query/N1qlQueryCreatorTest.java Normal file
View File

@@ -0,0 +1,489 @@
package org.springframework.data.couchbase.repository.query;
import static org.junit.Assert.assertEquals;
import static org.springframework.data.couchbase.repository.query.N1qlQueryCreator.createExpression;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import com.couchbase.client.java.query.dsl.Expression;
import org.junit.Test;
import org.springframework.data.repository.query.parser.Part;
public class N1qlQueryCreatorTest {
//==== The tests below check mapping between a Part.Type and the corresponding N1QL expression ====
@Test
public void testBETWEEN() throws Exception {
Part.Type keyword = Part.Type.BETWEEN;
Iterator<Object> values = Arrays.<Object>asList("a", "b", 1, 2, "c", "d").iterator();
String expected = "doc.field BETWEEN \"a\" AND \"b\"";
String expectedNum = "doc.field BETWEEN 1 AND 2";
String expectedIgnoreCase = "LOWER(doc.field) BETWEEN LOWER(\"c\") AND LOWER(\"d\")";
Expression exp = createExpression(keyword, "doc.field", false, values);
Expression expNum = createExpression(keyword, "doc.field", false, values);
Expression expIgnoreCase = createExpression(keyword, "doc.field", true, values);
assertEquals(expected, exp.toString());
assertEquals(expectedNum, expNum.toString());
assertEquals(expectedIgnoreCase, expIgnoreCase.toString());
}
@Test
public void testIS_NOT_NULL() throws Exception {
Part.Type keyword = Part.Type.IS_NOT_NULL;
Iterator<Object> values = Arrays.<Object>asList("a", 1, "b").iterator();
String expected = "doc.field IS NOT NULL";
String expectedNum = "doc.field IS NOT NULL";
String expectedIgnoreCase = "LOWER(doc.field) IS NOT NULL";
Expression exp = createExpression(keyword, "doc.field", false, values);
Expression expNum = createExpression(keyword, "doc.field", false, values);
Expression expIgnoreCase = createExpression(keyword, "doc.field", true, values);
assertEquals(expected, exp.toString());
assertEquals(expectedNum, expNum.toString());
assertEquals(expectedIgnoreCase, expIgnoreCase.toString());
}
@Test
public void testIS_NULL() throws Exception {
Part.Type keyword = Part.Type.IS_NULL;
Iterator<Object> values = Arrays.<Object>asList("a", 1, "b").iterator();
String expected = "doc.field IS NULL";
String expectedNum = "doc.field IS NULL";
String expectedIgnoreCase = "LOWER(doc.field) IS NULL";
Expression exp = createExpression(keyword, "doc.field", false, values);
Expression expNum = createExpression(keyword, "doc.field", false, values);
Expression expIgnoreCase = createExpression(keyword, "doc.field", true, values);
assertEquals(expected, exp.toString());
assertEquals(expectedNum, expNum.toString());
assertEquals(expectedIgnoreCase, expIgnoreCase.toString());
}
@Test
public void testLESS_THAN() throws Exception {
Part.Type keyword = Part.Type.LESS_THAN;
Iterator<Object> values = Arrays.<Object>asList("a", 1, "b").iterator();
String expected = "doc.field < \"a\"";
String expectedNum = "doc.field < 1";
String expectedIgnoreCase = "LOWER(doc.field) < LOWER(\"b\")";
Expression exp = createExpression(keyword, "doc.field", false, values);
Expression expNum = createExpression(keyword, "doc.field", false, values);
Expression expIgnoreCase = createExpression(keyword, "doc.field", true, values);
assertEquals(expected, exp.toString());
assertEquals(expectedNum, expNum.toString());
assertEquals(expectedIgnoreCase, expIgnoreCase.toString());
}
@Test
public void testLESS_THAN_EQUAL() throws Exception {
Part.Type keyword = Part.Type.LESS_THAN_EQUAL;
Iterator<Object> values = Arrays.<Object>asList("a", 1, "b").iterator();
String expected = "doc.field <= \"a\"";
String expectedNum = "doc.field <= 1";
String expectedIgnoreCase = "LOWER(doc.field) <= LOWER(\"b\")";
Expression exp = createExpression(keyword, "doc.field", false, values);
Expression expNum = createExpression(keyword, "doc.field", false, values);
Expression expIgnoreCase = createExpression(keyword, "doc.field", true, values);
assertEquals(expected, exp.toString());
assertEquals(expectedNum, expNum.toString());
assertEquals(expectedIgnoreCase, expIgnoreCase.toString());
}
@Test
public void testGREATER_THAN() throws Exception {
Part.Type keyword = Part.Type.GREATER_THAN;
Iterator<Object> values = Arrays.<Object>asList("a", 1, "b").iterator();
String expected = "doc.field > \"a\"";
String expectedNum = "doc.field > 1";
String expectedIgnoreCase = "LOWER(doc.field) > LOWER(\"b\")";
Expression exp = createExpression(keyword, "doc.field", false, values);
Expression expNum = createExpression(keyword, "doc.field", false, values);
Expression expIgnoreCase = createExpression(keyword, "doc.field", true, values);
assertEquals(expected, exp.toString());
assertEquals(expectedNum, expNum.toString());
assertEquals(expectedIgnoreCase, expIgnoreCase.toString());
}
@Test
public void testGREATER_THAN_EQUAL() throws Exception {
Part.Type keyword = Part.Type.GREATER_THAN_EQUAL;
Iterator<Object> values = Arrays.<Object>asList("a", 1, "b").iterator();
String expected = "doc.field >= \"a\"";
String expectedNum = "doc.field >= 1";
String expectedIgnoreCase = "LOWER(doc.field) >= LOWER(\"b\")";
Expression exp = createExpression(keyword, "doc.field", false, values);
Expression expNum = createExpression(keyword, "doc.field", false, values);
Expression expIgnoreCase = createExpression(keyword, "doc.field", true, values);
assertEquals(expected, exp.toString());
assertEquals(expectedNum, expNum.toString());
assertEquals(expectedIgnoreCase, expIgnoreCase.toString());
}
@Test
public void testBEFORE() throws Exception {
Part.Type keyword = Part.Type.BEFORE;
Iterator<Object> values = Arrays.<Object>asList("a", 1, "b").iterator();
String expected = "doc.field < \"a\"";
String expectedNum = "doc.field < 1";
String expectedIgnoreCase = "LOWER(doc.field) < LOWER(\"b\")";
Expression exp = createExpression(keyword, "doc.field", false, values);
Expression expNum = createExpression(keyword, "doc.field", false, values);
Expression expIgnoreCase = createExpression(keyword, "doc.field", true, values);
assertEquals(expected, exp.toString());
assertEquals(expectedNum, expNum.toString());
assertEquals(expectedIgnoreCase, expIgnoreCase.toString());
}
@Test
public void testAFTER() throws Exception {
Part.Type keyword = Part.Type.AFTER;
Iterator<Object> values = Arrays.<Object>asList("a", 1, "b").iterator();
String expected = "doc.field > \"a\"";
String expectedNum = "doc.field > 1";
String expectedIgnoreCase = "LOWER(doc.field) > LOWER(\"b\")";
Expression exp = createExpression(keyword, "doc.field", false, values);
Expression expNum = createExpression(keyword, "doc.field", false, values);
Expression expIgnoreCase = createExpression(keyword, "doc.field", true, values);
assertEquals(expected, exp.toString());
assertEquals(expectedNum, expNum.toString());
assertEquals(expectedIgnoreCase, expIgnoreCase.toString());
}
@Test
public void testNOT_LIKE() throws Exception {
Part.Type keyword = Part.Type.NOT_LIKE;
Iterator<Object> values = Arrays.<Object>asList("a", 1, "b").iterator();
String expected = "doc.field NOT LIKE \"a\"";
String expectedNum = "doc.field NOT LIKE 1";
String expectedIgnoreCase = "LOWER(doc.field) NOT LIKE LOWER(\"b\")";
Expression exp = createExpression(keyword, "doc.field", false, values);
Expression expNum = createExpression(keyword, "doc.field", false, values);
Expression expIgnoreCase = createExpression(keyword, "doc.field", true, values);
assertEquals(expected, exp.toString());
assertEquals(expectedNum, expNum.toString());
assertEquals(expectedIgnoreCase, expIgnoreCase.toString());
}
@Test
public void testLIKE() throws Exception {
Part.Type keyword = Part.Type.LIKE;
Iterator<Object> values = Arrays.<Object>asList("a", 1, "b").iterator();
String expected = "doc.field LIKE \"a\"";
String expectedNum = "doc.field LIKE 1";
String expectedIgnoreCase = "LOWER(doc.field) LIKE LOWER(\"b\")";
Expression exp = createExpression(keyword, "doc.field", false, values);
Expression expNum = createExpression(keyword, "doc.field", false, values);
Expression expIgnoreCase = createExpression(keyword, "doc.field", true, values);
assertEquals(expected, exp.toString());
assertEquals(expectedNum, expNum.toString());
assertEquals(expectedIgnoreCase, expIgnoreCase.toString());
}
@Test
public void testSTARTING_WITH() throws Exception {
Part.Type keyword = Part.Type.STARTING_WITH;
Iterator<Object> values = Arrays.<Object>asList("a", 1, "b").iterator();
String expected = "doc.field LIKE \"a%\"";
String expectedNum = "doc.field LIKE 1";
String expectedIgnoreCase = "LOWER(doc.field) LIKE LOWER(\"b%\")";
Expression exp = createExpression(keyword, "doc.field", false, values);
Expression expNum = createExpression(keyword, "doc.field", false, values);
Expression expIgnoreCase = createExpression(keyword, "doc.field", true, values);
assertEquals(expected, exp.toString());
assertEquals(expectedNum, expNum.toString());
assertEquals(expectedIgnoreCase, expIgnoreCase.toString());
}
@Test
public void testENDING_WITH() throws Exception {
Part.Type keyword = Part.Type.ENDING_WITH;
Iterator<Object> values = Arrays.<Object>asList("a", 1, "b").iterator();
String expected = "doc.field LIKE \"%a\"";
String expectedNum = "doc.field LIKE 1";
String expectedIgnoreCase = "LOWER(doc.field) LIKE LOWER(\"%b\")";
Expression exp = createExpression(keyword, "doc.field", false, values);
Expression expNum = createExpression(keyword, "doc.field", false, values);
Expression expIgnoreCase = createExpression(keyword, "doc.field", true, values);
assertEquals(expected, exp.toString());
assertEquals(expectedNum, expNum.toString());
assertEquals(expectedIgnoreCase, expIgnoreCase.toString());
}
@Test
public void testNOT_CONTAINING() throws Exception {
Part.Type keyword = Part.Type.NOT_CONTAINING;
Iterator<Object> values = Arrays.<Object>asList("a", 1, "b").iterator();
String expected = "doc.field NOT LIKE \"%a%\"";
String expectedNum = "doc.field NOT LIKE 1";
String expectedIgnoreCase = "LOWER(doc.field) NOT LIKE LOWER(\"%b%\")";
Expression exp = createExpression(keyword, "doc.field", false, values);
Expression expNum = createExpression(keyword, "doc.field", false, values);
Expression expIgnoreCase = createExpression(keyword, "doc.field", true, values);
assertEquals(expected, exp.toString());
assertEquals(expectedNum, expNum.toString());
assertEquals(expectedIgnoreCase, expIgnoreCase.toString());
}
@Test
public void testCONTAINING() throws Exception {
Part.Type keyword = Part.Type.CONTAINING;
Iterator<Object> values = Arrays.<Object>asList("a", 1, "b").iterator();
String expected = "doc.field LIKE \"%a%\"";
String expectedNum = "doc.field LIKE 1";
String expectedIgnoreCase = "LOWER(doc.field) LIKE LOWER(\"%b%\")";
Expression exp = createExpression(keyword, "doc.field", false, values);
Expression expNum = createExpression(keyword, "doc.field", false, values);
Expression expIgnoreCase = createExpression(keyword, "doc.field", true, values);
assertEquals(expected, exp.toString());
assertEquals(expectedNum, expNum.toString());
assertEquals(expectedIgnoreCase, expIgnoreCase.toString());
}
@Test
public void testNOT_IN() throws Exception {
Part.Type keyword = Part.Type.NOT_IN;
Iterator<Object> values = Arrays.<Object>asList("a", 1, "b").iterator();
String expected = "doc.field NOT IN [\"a\"]";
String expectedNum = "doc.field NOT IN [1]";
String expectedIgnoreCase = "LOWER(doc.field) NOT IN [\"b\"]";
Expression exp = createExpression(keyword, "doc.field", false, values);
Expression expNum = createExpression(keyword, "doc.field", false, values);
Expression expIgnoreCase = createExpression(keyword, "doc.field", true, values);
assertEquals(expected, exp.toString());
assertEquals(expectedNum, expNum.toString());
assertEquals(expectedIgnoreCase, expIgnoreCase.toString());
}
@Test
public void testNOTINwithCollection() throws Exception {
Part.Type keyword = Part.Type.NOT_IN;
List<Object> val1 = Arrays.<Object>asList("av1", "av2");
List<Object> val2 = Arrays.<Object>asList("bv1", "bv2");
Iterator<Object> values = Arrays.<Object>asList(val1, val2).iterator();
String expected = "doc.field NOT IN [\"av1\",\"av2\"]";
String expectedIgnoreCase = "LOWER(doc.field) NOT IN [\"bv1\",\"bv2\"]";
Expression exp = createExpression(keyword, "doc.field", false, values);
Expression expIgnoreCase = createExpression(keyword, "doc.field", true, values);
assertEquals(expected, exp.toString());
assertEquals(expectedIgnoreCase, expIgnoreCase.toString());
}
@Test
public void testNOTINwithArray() throws Exception {
Part.Type keyword = Part.Type.NOT_IN;
String[] val1 = {"av1", "av2"};
String[] val2 = {"bv1", "bv2"};
Iterator<Object> values = Arrays.<Object>asList(val1, val2).iterator();
String expected = "doc.field NOT IN [\"av1\",\"av2\"]";
String expectedIgnoreCase = "LOWER(doc.field) NOT IN [\"bv1\",\"bv2\"]";
Expression exp = createExpression(keyword, "doc.field", false, values);
Expression expIgnoreCase = createExpression(keyword, "doc.field", true, values);
assertEquals(expected, exp.toString());
assertEquals(expectedIgnoreCase, expIgnoreCase.toString());
}
@Test
public void testIN() throws Exception {
Part.Type keyword = Part.Type.IN;
Iterator<Object> values = Arrays.<Object>asList("a", 1, "b").iterator();
String expected = "doc.field IN [\"a\"]";
String expectedNum = "doc.field IN [1]";
String expectedIgnoreCase = "LOWER(doc.field) IN [\"b\"]";
Expression exp = createExpression(keyword, "doc.field", false, values);
Expression expNum = createExpression(keyword, "doc.field", false, values);
Expression expIgnoreCase = createExpression(keyword, "doc.field", true, values);
assertEquals(expected, exp.toString());
assertEquals(expectedNum, expNum.toString());
assertEquals(expectedIgnoreCase, expIgnoreCase.toString());
}
@Test
public void testINwithCollection() throws Exception {
Part.Type keyword = Part.Type.IN;
List<Object> val1 = Arrays.<Object>asList("av1", "av2");
List<Object> val2 = Arrays.<Object>asList("bv1", "bv2");
Iterator<Object> values = Arrays.<Object>asList(val1, val2).iterator();
String expected = "doc.field IN [\"av1\",\"av2\"]";
String expectedIgnoreCase = "LOWER(doc.field) IN [\"bv1\",\"bv2\"]";
Expression exp = createExpression(keyword, "doc.field", false, values);
Expression expIgnoreCase = createExpression(keyword, "doc.field", true, values);
assertEquals(expected, exp.toString());
assertEquals(expectedIgnoreCase, expIgnoreCase.toString());
}
@Test
public void testINwithArray() throws Exception {
Part.Type keyword = Part.Type.IN;
String[] val1 = {"av1", "av2"};
String[] val2 = {"bv1", "bv2"};
Iterator<Object> values = Arrays.<Object>asList(val1, val2).iterator();
String expected = "doc.field IN [\"av1\",\"av2\"]";
String expectedIgnoreCase = "LOWER(doc.field) IN [\"bv1\",\"bv2\"]";
Expression exp = createExpression(keyword, "doc.field", false, values);
Expression expIgnoreCase = createExpression(keyword, "doc.field", true, values);
assertEquals(expected, exp.toString());
assertEquals(expectedIgnoreCase, expIgnoreCase.toString());
}
@Test(expected = IllegalArgumentException.class)
public void testNEAR() throws Exception {
Part.Type keyword = Part.Type.NEAR;
Iterator<Object> values = Arrays.<Object>asList("a", 1, "b").iterator();
Expression exp = createExpression(keyword, "doc.field", true, values);
}
@Test(expected = IllegalArgumentException.class)
public void testWITHIN() throws Exception {
Part.Type keyword = Part.Type.WITHIN;
Iterator<Object> values = Arrays.<Object>asList("a", 1, "b").iterator();
Expression exp = createExpression(keyword, "doc.field", false, values);
}
@Test
public void testREGEX() throws Exception {
Part.Type keyword = Part.Type.REGEX;
Iterator<Object> values = Arrays.<Object>asList("a", 1, "b").iterator();
String expected = "REGEXP_LIKE(doc.field, \"a\")";
String expectedNum = "REGEXP_LIKE(doc.field, \"1\")";
String expectedIgnoreCase = "REGEXP_LIKE(doc.field, \"b\")";
Expression exp = createExpression(keyword, "doc.field", false, values);
Expression expNum = createExpression(keyword, "doc.field", false, values);
Expression expIgnoreCase = createExpression(keyword, "doc.field", true, values);
assertEquals(expected, exp.toString());
assertEquals(expectedNum, expNum.toString());
assertEquals(expectedIgnoreCase, expIgnoreCase.toString());
}
@Test
public void testEXISTS() throws Exception {
Part.Type keyword = Part.Type.EXISTS;
Iterator<Object> values = Arrays.<Object>asList("a", 1, "b").iterator();
String expected = "doc.field IS NOT MISSING";
String expectedNum = "doc.field IS NOT MISSING";
String expectedIgnoreCase = "LOWER(doc.field) IS NOT MISSING";
Expression exp = createExpression(keyword, "doc.field", false, values);
Expression expNum = createExpression(keyword, "doc.field", false, values);
Expression expIgnoreCase = createExpression(keyword, "doc.field", true, values);
assertEquals(expected, exp.toString());
assertEquals(expectedNum, expNum.toString());
assertEquals(expectedIgnoreCase, expIgnoreCase.toString());
}
@Test
public void testTRUE() throws Exception {
Part.Type keyword = Part.Type.TRUE;
Iterator<Object> values = Arrays.<Object>asList("a", 1, "b").iterator();
String expected = "doc.field = TRUE";
String expectedNum = "doc.field = TRUE";
String expectedIgnoreCase = "LOWER(doc.field) = TRUE";
Expression exp = createExpression(keyword, "doc.field", false, values);
Expression expNum = createExpression(keyword, "doc.field", false, values);
Expression expIgnoreCase = createExpression(keyword, "doc.field", true, values);
assertEquals(expected, exp.toString());
assertEquals(expectedNum, expNum.toString());
assertEquals(expectedIgnoreCase, expIgnoreCase.toString());
}
@Test
public void testFALSE() throws Exception {
Part.Type keyword = Part.Type.FALSE;
Iterator<Object> values = Arrays.<Object>asList("a", 1, "b").iterator();
String expected = "doc.field = FALSE";
String expectedNum = "doc.field = FALSE";
String expectedIgnoreCase = "LOWER(doc.field) = FALSE";
Expression exp = createExpression(keyword, "doc.field", false, values);
Expression expNum = createExpression(keyword, "doc.field", false, values);
Expression expIgnoreCase = createExpression(keyword, "doc.field", true, values);
assertEquals(expected, exp.toString());
assertEquals(expectedNum, expNum.toString());
assertEquals(expectedIgnoreCase, expIgnoreCase.toString());
}
@Test
public void testNEGATING_SIMPLE_PROPERTY() throws Exception {
Part.Type keyword = Part.Type.NEGATING_SIMPLE_PROPERTY;
Iterator<Object> values = Arrays.<Object>asList("a", 1, "b").iterator();
String expected = "doc.field != \"a\"";
String expectedNum = "doc.field != 1";
String expectedIgnoreCase = "LOWER(doc.field) != LOWER(\"b\")";
Expression exp = createExpression(keyword, "doc.field", false, values);
Expression expNum = createExpression(keyword, "doc.field", false, values);
Expression expIgnoreCase = createExpression(keyword, "doc.field", true, values);
assertEquals(expected, exp.toString());
assertEquals(expectedNum, expNum.toString());
assertEquals(expectedIgnoreCase, expIgnoreCase.toString());
}
@Test
public void testSIMPLE_PROPERTY() throws Exception {
Part.Type keyword = Part.Type.SIMPLE_PROPERTY;
Iterator<Object> values = Arrays.<Object>asList("a", 1, "b").iterator();
String expected = "doc.field = \"a\"";
String expectedNum = "doc.field = 1";
String expectedIgnoreCase = "LOWER(doc.field) = LOWER(\"b\")";
Expression exp = createExpression(keyword, "doc.field", false, values);
Expression expNum = createExpression(keyword, "doc.field", false, values);
Expression expIgnoreCase = createExpression(keyword, "doc.field", true, values);
assertEquals(expected, exp.toString());
assertEquals(expectedNum, expNum.toString());
assertEquals(expectedIgnoreCase, expIgnoreCase.toString());
}
}