[DATAES-433] Support join datatype.

Original PR: spring-projects#485

Author: sbcd90

src/main/java/org/springframework/data/elasticsearch/annotations/JoinTypeRelation.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.elasticsearch.annotations;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * @author Subhobrata Dey
+ * @since 4.1
+ */
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.ANNOTATION_TYPE)
+public @interface JoinTypeRelation {
+
+    String parent();
+
+    String[] children();
+}

src/main/java/org/springframework/data/elasticsearch/annotations/JoinTypeRelations.java

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.elasticsearch.annotations;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * @author Subhobrata Dey
+ * @since 4.1
+ */
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+@Inherited
+public @interface JoinTypeRelations {
+
+    JoinTypeRelation[] relations();
+}

src/main/java/org/springframework/data/elasticsearch/core/AbstractElasticsearchTemplate.java

@@ -39,6 +39,8 @@
 import org.springframework.context.ApplicationContextAware;
 import org.springframework.data.convert.EntityReader;
 import org.springframework.data.elasticsearch.BulkFailureException;
+import org.springframework.data.elasticsearch.core.join.JoinField;
+import org.springframework.data.elasticsearch.annotations.JoinTypeRelations;
 import org.springframework.data.elasticsearch.core.convert.ElasticsearchConverter;
 import org.springframework.data.elasticsearch.core.convert.MappingElasticsearchConverter;
 import org.springframework.data.elasticsearch.core.document.Document;
@@ -532,6 +534,22 @@ private String getEntityId(Object entity) {
 		return null;
 	}
 
+	@Nullable
+	private String getEntityRouting(Object entity) {
+		ElasticsearchPersistentEntity<?> persistentEntity = getRequiredPersistentEntity(entity.getClass());
+		ElasticsearchPersistentProperty joinProperty = persistentEntity.getJoinFieldProperty();
+
+		if (joinProperty != null) {
+			Object joinField = persistentEntity.getPropertyAccessor(entity).getProperty(joinProperty);
+			if (joinField != null && JoinField.class.isAssignableFrom(joinField.getClass())
+				&& ((JoinField<?>) joinField).getParent() != null) {
+				return elasticsearchConverter.convertId(((JoinField<?>) joinField).getParent());
+			}
+		}
+
+		return null;
+	}
+
 	@Nullable
 	private Long getEntityVersion(Object entity) {
 		ElasticsearchPersistentEntity<?> persistentEntity = getRequiredPersistentEntity(entity.getClass());
@@ -581,6 +599,11 @@ private <T> IndexQuery getIndexQuery(T entity) {
 			// version cannot be used together with seq_no and primary_term
 			builder.withVersion(getEntityVersion(entity));
 		}
+
+		String routing = getEntityRouting(entity);
+		if (routing != null) {
+			builder.withRouting(routing);
+		}
 		return builder.build();
 	}
 

src/main/java/org/springframework/data/elasticsearch/core/RequestFactory.java

@@ -743,6 +743,10 @@ public DeleteByQueryRequest deleteByQueryRequest(Query query, Class<?> clazz, In
 			deleteByQueryRequest.setScroll(TimeValue.timeValueMillis(query.getScrollTime().toMillis()));
 		}
 
+		if (query.getRoute() != null) {
+			deleteByQueryRequest.setRouting(query.getRoute());
+		}
+
 		return deleteByQueryRequest;
 	}
 
@@ -798,6 +802,10 @@ public DeleteByQueryRequestBuilder deleteByQueryRequestBuilder(Client client, Qu
 			source.setScroll(TimeValue.timeValueMillis(query.getScrollTime().toMillis()));
 		}
 
+		if (query.getRoute() != null) {
+			source.setRouting(query.getRoute());
+		}
+
 		return requestBuilder;
 	}
 	// endregion
@@ -888,6 +896,10 @@ public IndexRequest indexRequest(IndexQuery query, IndexCoordinates index) {
 			indexRequest.setIfPrimaryTerm(query.getPrimaryTerm());
 		}
 
+		if (query.getRouting() != null) {
+			indexRequest.routing(query.getRouting());
+		}
+
 		return indexRequest;
 	}
 
@@ -926,6 +938,9 @@ public IndexRequestBuilder indexRequestBuilder(Client client, IndexQuery query,
 		if (query.getPrimaryTerm() != null) {
 			indexRequestBuilder.setIfPrimaryTerm(query.getPrimaryTerm());
 		}
+		if (query.getRouting() != null) {
+			indexRequestBuilder.setRouting(query.getRouting());
+		}
 
 		return indexRequestBuilder;
 	}

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

@@ -44,6 +44,7 @@
 import org.springframework.data.elasticsearch.annotations.ScriptedField;
 import org.springframework.data.elasticsearch.core.document.Document;
 import org.springframework.data.elasticsearch.core.document.SearchDocument;
+import org.springframework.data.elasticsearch.core.join.JoinField;
 import org.springframework.data.elasticsearch.core.mapping.ElasticsearchPersistentEntity;
 import org.springframework.data.elasticsearch.core.mapping.ElasticsearchPersistentProperty;
 import org.springframework.data.elasticsearch.core.mapping.ElasticsearchPersistentPropertyConverter;
@@ -710,6 +711,13 @@ private boolean requiresTypeHint(TypeInformation<?> type, Class<?> actualType,
 			if (container.equals(type) && type.getType().equals(actualType)) {
 				return false;
 			}
+
+			if (container.getRawTypeInformation().equals(type)) {
+				Class<?> containerClass = container.getRawTypeInformation().getType();
+				if (containerClass.equals(JoinField.class) && type.getType().equals(actualType)) {
+					return false;
+				}
+			}
 		}
 
 		return !conversions.isSimpleType(type.getType()) && !type.isCollectionLike()

src/main/java/org/springframework/data/elasticsearch/core/index/MappingBuilder.java

@@ -40,13 +40,16 @@
 import org.springframework.data.elasticsearch.annotations.FieldType;
 import org.springframework.data.elasticsearch.annotations.GeoPointField;
 import org.springframework.data.elasticsearch.annotations.InnerField;
+import org.springframework.data.elasticsearch.annotations.JoinTypeRelation;
+import org.springframework.data.elasticsearch.annotations.JoinTypeRelations;
 import org.springframework.data.elasticsearch.annotations.Mapping;
 import org.springframework.data.elasticsearch.annotations.MultiField;
 import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate;
 import org.springframework.data.elasticsearch.core.ResourceUtil;
 import org.springframework.data.elasticsearch.core.completion.Completion;
 import org.springframework.data.elasticsearch.core.convert.ElasticsearchConverter;
 import org.springframework.data.elasticsearch.core.geo.GeoPoint;
+import org.springframework.data.elasticsearch.core.join.JoinField;
 import org.springframework.data.elasticsearch.core.mapping.ElasticsearchPersistentEntity;
 import org.springframework.data.elasticsearch.core.mapping.ElasticsearchPersistentProperty;
 import org.springframework.data.mapping.MappingException;
@@ -73,6 +76,7 @@
  * @author Petr Kukral
  * @author Peter-Josef Meisch
  * @author Xiao Yu
+ * @author Subhobrata Dey
  */
 public class MappingBuilder {
 
@@ -93,8 +97,11 @@ public class MappingBuilder {
 	private static final String TYPE_DYNAMIC = "dynamic";
 	private static final String TYPE_VALUE_KEYWORD = "keyword";
 	private static final String TYPE_VALUE_GEO_POINT = "geo_point";
+	private static final String TYPE_VALUE_JOIN = "join";
 	private static final String TYPE_VALUE_COMPLETION = "completion";
 
+	private static final String JOIN_TYPE_RELATIONS = "relations";
+
 	private static final Logger logger = LoggerFactory.getLogger(ElasticsearchRestTemplate.class);
 
 	private final ElasticsearchConverter elasticsearchConverter;
@@ -212,6 +219,10 @@ private void buildPropertyMapping(XContentBuilder builder, boolean isRootObject,
 			return;
 		}
 
+		if (isJoinFieldProperty(property)) {
+			addJoinFieldMapping(builder, property);
+		}
+
 		Field fieldAnnotation = property.findAnnotation(Field.class);
 		boolean isCompletionProperty = isCompletionProperty(property);
 		boolean isNestedOrObjectProperty = isNestedOrObjectProperty(property);
@@ -336,6 +347,36 @@ private void addSingleFieldMapping(XContentBuilder builder, ElasticsearchPersist
 		builder.endObject();
 	}
 
+	private void addJoinFieldMapping(XContentBuilder builder,
+									 ElasticsearchPersistentProperty property) throws IOException {
+		JoinTypeRelation[] joinTypeRelations = property.getRequiredAnnotation(JoinTypeRelations.class).relations();
+
+		if (joinTypeRelations.length == 0) {
+			logger.warn("Property {}s type is JoinField but its annotation JoinTypeRelation is " + //
+							"not properly maintained", //
+					property.getFieldName());
+			return;
+		}
+		builder.startObject(property.getFieldName());
+
+		builder.field(FIELD_PARAM_TYPE, TYPE_VALUE_JOIN);
+
+		builder.startObject(JOIN_TYPE_RELATIONS);
+
+		for (JoinTypeRelation joinTypeRelation: joinTypeRelations) {
+			String parent = joinTypeRelation.parent();
+			String[] children = joinTypeRelation.children();
+
+			if (children.length > 1) {
+				builder.array(parent, children);
+			} else if (children.length == 1) {
+				builder.field(parent, children[0]);
+			}
+		}
+		builder.endObject();
+		builder.endObject();
+	}
+
 	/**
 	 * Add mapping for @MultiField annotation
 	 *
@@ -423,6 +464,10 @@ private boolean isGeoPointProperty(ElasticsearchPersistentProperty property) {
 		return property.getActualType() == GeoPoint.class || property.isAnnotationPresent(GeoPointField.class);
 	}
 
+	private boolean isJoinFieldProperty(ElasticsearchPersistentProperty property) {
+		return property.getActualType() == JoinField.class;
+	}
+
 	private boolean isCompletionProperty(ElasticsearchPersistentProperty property) {
 		return property.getActualType() == Completion.class;
 	}

src/main/java/org/springframework/data/elasticsearch/core/join/JoinField.java

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.elasticsearch.core.join;
+
+import org.springframework.lang.Nullable;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @author Subhobrata Dey
+ * @since 4.1
+ */
+public class JoinField<ID> {
+
+    private final String name;
+
+    @Nullable private ID parent;
+
+    public JoinField() {
+        this("default", null);
+    }
+
+    public JoinField(String name) {
+        this(name, null);
+    }
+
+    public JoinField(String name, @Nullable ID parent) {
+        this.name = name;
+        this.parent = parent;
+    }
+
+    public void setParent(@Nullable ID parent) {
+        this.parent = parent;
+    }
+
+    @Nullable
+    public ID getParent() {
+        return parent;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public Map<String, Object> getAsMap() {
+        Map<String, Object> joinMap = new HashMap<>();
+        joinMap.put("name", getName());
+        joinMap.put("parent", getParent());
+
+        return Collections.unmodifiableMap(joinMap);
+    }
+}