Skip to content

Commit 049d680

Browse files
xhaggixhaggi
committed
Add native support for range field types by using a range object
1 parent 679f99a commit 049d680

13 files changed

+1197
-27
lines changed

‎src/main/java/org/springframework/data/elasticsearch/core/Range.java

+444
Large diffs are not rendered by default.

‎src/main/java/org/springframework/data/elasticsearch/core/convert/AbstractRangePersistentPropertyConverter.java

+116
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,116 @@
1+
/*
2+
* Copyright 2021 the original author or authors.
3+
*
4+
* Licensed under the Apache License, Version 2.0 (the "License");
5+
* you may not use this file except in compliance with the License.
6+
* You may obtain a copy of the License at
7+
*
8+
* https://www.apache.org/licenses/LICENSE-2.0
9+
*
10+
* Unless required by applicable law or agreed to in writing, software
11+
* distributed under the License is distributed on an "AS IS" BASIS,
12+
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13+
* See the License for the specific language governing permissions and
14+
* limitations under the License.
15+
*/
16+
package org.springframework.data.elasticsearch.core.convert;
17+
18+
import java.util.LinkedHashMap;
19+
import java.util.Map;
20+
21+
import org.springframework.data.elasticsearch.core.Range;
22+
import org.springframework.data.mapping.PersistentProperty;
23+
import org.springframework.util.Assert;
24+
25+
/**
26+
* @author Sascha Woo
27+
* @since 4.3
28+
*/
29+
public abstract class AbstractRangePersistentPropertyConverter<T> extends AbstractPersistentPropertyConverter {
30+
31+
public AbstractRangePersistentPropertyConverter(PersistentProperty<?> property) {
32+
super(property);
33+
}
34+
35+
@Override
36+
public Object read(Object value) {
37+
38+
Assert.notNull(value, "value must not be null.");
39+
Assert.isInstanceOf(Map.class, value, "value must be instance of Map.");
40+
41+
try {
42+
Map<String, Object> source = (Map<String, Object>) value;
43+
Range.Bound<T> lowerBound;
44+
Range.Bound<T> upperBound;
45+
46+
if (source.containsKey("lte")) {
47+
lowerBound = Range.Bound.inclusive(parse((String) source.get("lte")));
48+
} else if (source.containsKey("lt")) {
49+
lowerBound = Range.Bound.exclusive(parse((String) source.get("lt")));
50+
} else {
51+
lowerBound = Range.Bound.unbounded();
52+
}
53+
54+
if (source.containsKey("gte")) {
55+
upperBound = Range.Bound.inclusive(parse((String) source.get("gte")));
56+
} else if (source.containsKey("gt")) {
57+
upperBound = Range.Bound.exclusive(parse((String) source.get("gt")));
58+
} else {
59+
upperBound = Range.Bound.unbounded();
60+
}
61+
62+
return Range.of(lowerBound, upperBound);
63+
64+
} catch (Exception e) {
65+
throw new ConversionException(
66+
String.format("Unable to convert value '%s' of property '%s'", value, getProperty().getName()), e);
67+
}
68+
}
69+
70+
@Override
71+
public Object write(Object value) {
72+
73+
Assert.notNull(value, "value must not be null.");
74+
Assert.isInstanceOf(Range.class, value, "value must be instance of Range.");
75+
76+
try {
77+
Range<T> range = (Range<T>) value;
78+
Range.Bound<T> lowerBound = range.getLowerBound();
79+
Range.Bound<T> upperBound = range.getUpperBound();
80+
Map<String, Object> target = new LinkedHashMap<>();
81+
82+
if (lowerBound.isBounded()) {
83+
String lowerBoundValue = format(lowerBound.getValue().get());
84+
if (lowerBound.isInclusive()) {
85+
target.put("lte", lowerBoundValue);
86+
} else {
87+
target.put("lt", lowerBoundValue);
88+
}
89+
}
90+
91+
if (upperBound.isBounded()) {
92+
String upperBoundValue = format(upperBound.getValue().get());
93+
if (upperBound.isInclusive()) {
94+
target.put("gte", upperBoundValue);
95+
} else {
96+
target.put("gt", upperBoundValue);
97+
}
98+
}
99+
100+
return target;
101+
102+
} catch (Exception e) {
103+
throw new ConversionException(
104+
String.format("Unable to convert value '%s' of property '%s'", value, getProperty().getName()), e);
105+
}
106+
}
107+
108+
protected abstract String format(T value);
109+
110+
protected Class<?> getGenericType() {
111+
return getProperty().getTypeInformation().getTypeArguments().get(0).getType();
112+
}
113+
114+
protected abstract T parse(String value);
115+
116+
}

‎src/main/java/org/springframework/data/elasticsearch/core/convert/DatePersistentPropertyConverter.java

+6-4
Original file line numberDiff line numberDiff line change
@@ -40,22 +40,24 @@ public DatePersistentPropertyConverter(PersistentProperty<?> property,
4040
}
4141

4242
@Override
43-
public Object read(String value) {
43+
public Object read(Object value) {
44+
45+
String s = value.toString();
4446

4547
for (ElasticsearchDateConverter dateConverter : dateConverters) {
4648
try {
47-
return dateConverter.parse(value);
49+
return dateConverter.parse(s);
4850
} catch (Exception e) {
4951
LOGGER.trace(e.getMessage(), e);
5052
}
5153
}
5254

53-
throw new ConversionException(String.format("Unable to convert value '%s' to %s for property '%s'", value,
55+
throw new ConversionException(String.format("Unable to convert value '%s' to %s for property '%s'", s,
5456
getProperty().getActualType().getTypeName(), getProperty().getName()));
5557
}
5658

5759
@Override
58-
public String write(Object value) {
60+
public Object write(Object value) {
5961

6062
try {
6163
return dateConverters.get(0).format((Date) value);

‎src/main/java/org/springframework/data/elasticsearch/core/convert/DateRangePersistentPropertyConverter.java

+62
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,62 @@
1+
/*
2+
* Copyright 2021 the original author or authors.
3+
*
4+
* Licensed under the Apache License, Version 2.0 (the "License");
5+
* you may not use this file except in compliance with the License.
6+
* You may obtain a copy of the License at
7+
*
8+
* https://www.apache.org/licenses/LICENSE-2.0
9+
*
10+
* Unless required by applicable law or agreed to in writing, software
11+
* distributed under the License is distributed on an "AS IS" BASIS,
12+
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13+
* See the License for the specific language governing permissions and
14+
* limitations under the License.
15+
*/
16+
package org.springframework.data.elasticsearch.core.convert;
17+
18+
import java.util.Date;
19+
import java.util.List;
20+
21+
import org.slf4j.Logger;
22+
import org.slf4j.LoggerFactory;
23+
import org.springframework.data.mapping.PersistentProperty;
24+
25+
/**
26+
* @author Sascha Woo
27+
* @since 4.3
28+
*/
29+
public class DateRangePersistentPropertyConverter extends AbstractRangePersistentPropertyConverter<Date> {
30+
31+
private static final Logger LOGGER = LoggerFactory.getLogger(DateRangePersistentPropertyConverter.class);
32+
33+
private final List<ElasticsearchDateConverter> dateConverters;
34+
35+
public DateRangePersistentPropertyConverter(PersistentProperty<?> property,
36+
List<ElasticsearchDateConverter> dateConverters) {
37+
38+
super(property);
39+
this.dateConverters = dateConverters;
40+
}
41+
42+
@Override
43+
protected String format(Date value) {
44+
return dateConverters.get(0).format(value);
45+
}
46+
47+
@Override
48+
protected Date parse(String value) {
49+
50+
for (ElasticsearchDateConverter converters : dateConverters) {
51+
try {
52+
return converters.parse(value);
53+
} catch (Exception e) {
54+
LOGGER.trace(e.getMessage(), e);
55+
}
56+
}
57+
58+
throw new ConversionException(String.format("Unable to convert value '%s' to %s for property '%s'", value,
59+
getGenericType().getTypeName(), getProperty().getName()));
60+
}
61+
62+
}

‎src/main/java/org/springframework/data/elasticsearch/core/convert/MappingElasticsearchConverter.java

+1-4
Original file line numberDiff line numberDiff line change
@@ -482,10 +482,7 @@ private Object propertyConverterRead(ElasticsearchPersistentProperty property, O
482482
}
483483

484484
private Object convertOnRead(ElasticsearchPersistentPropertyConverter propertyConverter, Object source) {
485-
if (String.class.isAssignableFrom(source.getClass())) {
486-
source = propertyConverter.read((String) source);
487-
}
488-
return source;
485+
return propertyConverter.read(source);
489486
}
490487

491488
/**

‎src/main/java/org/springframework/data/elasticsearch/core/convert/NumberRangePersistentPropertyConverter.java

+53
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,53 @@
1+
/*
2+
* Copyright 2021 the original author or authors.
3+
*
4+
* Licensed under the Apache License, Version 2.0 (the "License");
5+
* you may not use this file except in compliance with the License.
6+
* You may obtain a copy of the License at
7+
*
8+
* https://www.apache.org/licenses/LICENSE-2.0
9+
*
10+
* Unless required by applicable law or agreed to in writing, software
11+
* distributed under the License is distributed on an "AS IS" BASIS,
12+
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13+
* See the License for the specific language governing permissions and
14+
* limitations under the License.
15+
*/
16+
package org.springframework.data.elasticsearch.core.convert;
17+
18+
import org.springframework.data.mapping.PersistentProperty;
19+
20+
/**
21+
* @author Sascha Woo
22+
* @since 4.3
23+
*/
24+
public class NumberRangePersistentPropertyConverter extends AbstractRangePersistentPropertyConverter<Number> {
25+
26+
public NumberRangePersistentPropertyConverter(PersistentProperty<?> property) {
27+
super(property);
28+
}
29+
30+
@Override
31+
protected String format(Number number) {
32+
return String.valueOf(number);
33+
}
34+
35+
@Override
36+
protected Number parse(String value) {
37+
38+
Class<?> type = getGenericType();
39+
if (Integer.class.isAssignableFrom(type)) {
40+
return Integer.valueOf(value);
41+
} else if (Float.class.isAssignableFrom(type)) {
42+
return Float.valueOf(value);
43+
} else if (Long.class.isAssignableFrom(type)) {
44+
return Long.valueOf(value);
45+
} else if (Double.class.isAssignableFrom(type)) {
46+
return Double.valueOf(value);
47+
}
48+
49+
throw new ConversionException(String.format("Unable to convert value '%s' to %s for property '%s'", value,
50+
type.getTypeName(), getProperty().getName()));
51+
}
52+
53+
}

‎src/main/java/org/springframework/data/elasticsearch/core/convert/TemporalPersistentPropertyConverter.java

+5-4
Original file line numberDiff line numberDiff line change
@@ -41,24 +41,25 @@ public TemporalPersistentPropertyConverter(PersistentProperty<?> property,
4141

4242
@SuppressWarnings("unchecked")
4343
@Override
44-
public Object read(String value) {
44+
public Object read(Object value) {
4545

46+
String s = value.toString();
4647
Class<?> actualType = getProperty().getActualType();
4748

4849
for (ElasticsearchDateConverter dateConverter : dateConverters) {
4950
try {
50-
return dateConverter.parse(value, (Class<? extends TemporalAccessor>) actualType);
51+
return dateConverter.parse(s, (Class<? extends TemporalAccessor>) actualType);
5152
} catch (Exception e) {
5253
LOGGER.trace(e.getMessage(), e);
5354
}
5455
}
5556

56-
throw new ConversionException(String.format("Unable to convert value '%s' to %s for property '%s'", value,
57+
throw new ConversionException(String.format("Unable to convert value '%s' to %s for property '%s'", s,
5758
getProperty().getActualType().getTypeName(), getProperty().getName()));
5859
}
5960

6061
@Override
61-
public String write(Object value) {
62+
public Object write(Object value) {
6263

6364
try {
6465
return dateConverters.get(0).format((TemporalAccessor) value);

‎src/main/java/org/springframework/data/elasticsearch/core/convert/TemporalRangePersistentPropertyConverter.java

+67
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,67 @@
1+
/*
2+
* Copyright 2021 the original author or authors.
3+
*
4+
* Licensed under the Apache License, Version 2.0 (the "License");
5+
* you may not use this file except in compliance with the License.
6+
* You may obtain a copy of the License at
7+
*
8+
* https://www.apache.org/licenses/LICENSE-2.0
9+
*
10+
* Unless required by applicable law or agreed to in writing, software
11+
* distributed under the License is distributed on an "AS IS" BASIS,
12+
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13+
* See the License for the specific language governing permissions and
14+
* limitations under the License.
15+
*/
16+
package org.springframework.data.elasticsearch.core.convert;
17+
18+
import java.time.temporal.TemporalAccessor;
19+
import java.util.List;
20+
21+
import org.slf4j.Logger;
22+
import org.slf4j.LoggerFactory;
23+
import org.springframework.data.mapping.PersistentProperty;
24+
import org.springframework.util.Assert;
25+
26+
/**
27+
* @author Sascha Woo
28+
* @since 4.3
29+
*/
30+
public class TemporalRangePersistentPropertyConverter
31+
extends AbstractRangePersistentPropertyConverter<TemporalAccessor> {
32+
33+
private static final Logger LOGGER = LoggerFactory.getLogger(TemporalRangePersistentPropertyConverter.class);
34+
35+
private final List<ElasticsearchDateConverter> dateConverters;
36+
37+
public TemporalRangePersistentPropertyConverter(PersistentProperty<?> property,
38+
List<ElasticsearchDateConverter> dateConverters) {
39+
40+
super(property);
41+
42+
Assert.notEmpty(dateConverters, "dateConverters must not be empty.");
43+
this.dateConverters = dateConverters;
44+
}
45+
46+
@Override
47+
protected String format(TemporalAccessor temporal) {
48+
return dateConverters.get(0).format(temporal);
49+
}
50+
51+
@Override
52+
protected TemporalAccessor parse(String value) {
53+
54+
Class<?> type = getGenericType();
55+
for (ElasticsearchDateConverter converters : dateConverters) {
56+
try {
57+
return converters.parse(value, (Class<? extends TemporalAccessor>) type);
58+
} catch (Exception e) {
59+
LOGGER.trace(e.getMessage(), e);
60+
}
61+
}
62+
63+
throw new ConversionException(String.format("Unable to convert value '%s' to %s for property '%s'", value,
64+
type.getTypeName(), getProperty().getName()));
65+
}
66+
67+
}

0 commit comments

Comments
 (0)