Add support for Compound Wildcard Indexes.

See #4471

Author: sxhinzvc

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/index/CompoundWildcardIndexDefinition.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2014-2023 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.mongodb.core.index;
+
+import org.bson.Document;
+import org.springframework.util.Assert;
+
+/**
+ * {@link CompoundWildcardIndexDefinition} is a specific {@link Index} that includes one {@link WildcardIndex} and
+ * one or more non-wildcard fields.
+ *
+ * @author Julia Lee
+ * @since 4.2
+ */
+public class CompoundWildcardIndexDefinition extends WildcardIndex {
+
+	private final Document indexKeys;
+
+	/**
+	 * Creates a new {@link CompoundWildcardIndexDefinition} for the given {@literal wildcardPath} and {@literal keys}.
+	 * If {@literal wildcardPath} is empty, the wildcard index will apply to the root entity, using {@code $**}.
+	 * <br />
+	 *
+	 * @param wildcardPath can be a {@literal empty} {@link String}.
+	 */
+	public CompoundWildcardIndexDefinition(String wildcardPath, Document indexKeys) {
+
+		super(wildcardPath);
+		this.indexKeys = indexKeys;
+	}
+
+	@Override
+	public Document getIndexKeys() {
+
+		Document document = new Document();
+		document.putAll(indexKeys);
+		document.putAll(super.getIndexKeys());
+		return document;
+	}
+
+	@Override
+	public Document getIndexOptions() {
+
+		Document options = super.getIndexOptions();
+		return options;
+	}
+}

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/index/CompoundWildcardIndexed.java

@@ -0,0 +1,131 @@
+/*
+ * Copyright 2011-2023 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.mongodb.core.index;
+
+import org.springframework.core.annotation.AliasFor;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Mark a class to use compound wildcard indexes. <br />
+ *
+ * <pre class="code">
+ * &#64;Document
+ * &#64;CompoundWildcardIndexed(wildcardFieldName = "address", fields = "{'firstname': 1}")
+ * class Person {
+ * 	String firstname;
+ * 	Address address;
+ * }
+ *
+ * db.product.createIndex({"address.$**": 1, "firstname": 1})
+ * </pre>
+ *
+ * {@literal wildcardProjection} can be used to specify keys to in-/exclude in the index.
+ *
+ * <pre class="code">
+ *
+ * &#64;Document
+ * &#64;CompoundWildcardIndexed(wildcardProjection = "{'address.zip': 0}", fields = "{'firstname': 1}")
+ * class Person {
+ * 	String firstname;
+ * 	Address address;
+ * }
+ *
+ * db.user.createIndex({"$**": 1, "firstname": 1}, {"wildcardProjection": {"address.zip": 0}})
+ * </pre>
+ *
+ * @author Julia Lee
+ */
+@Target({ ElementType.TYPE })
+@Documented
+@WildcardIndexed
+@CompoundIndex
+@Retention(RetentionPolicy.RUNTIME)
+public @interface CompoundWildcardIndexed {
+
+	/**
+	 * The name of the sub-field to which a wildcard index is applied. If empty, the wildcard term will resolve to "$**".
+	 *
+	 * @return empty by default.
+	 */
+	String wildcardFieldName() default "";
+
+	/**
+	 * Explicitly specify sub-fields to be in-/excluded as a {@link org.bson.Document#parse(String) parsable} String.
+	 * <br />
+	 * <strong>NOTE:</strong> Can only be applied on when wildcard term is "$**"
+	 *
+	 * @return empty by default.
+	 */
+	@AliasFor(annotation = WildcardIndexed.class, attribute = "wildcardProjection")
+	String wildcardProjection() default "";
+
+	/**
+	 * Definition of non-wildcard index(es) in JSON format, wherein the keys are the fields to be indexed and the values
+	 * define the index direction (1 for ascending, -1 for descending). <br />
+	 *
+	 * <pre class="code">
+   * &#64;Document
+   * &#64;CompoundWildcardIndexed(wildcardProjection = "{ 'address.zip' : 0 }", fields = "{'firstname': 1}")
+   * class Person {
+   * 	String firstname;
+   * 	Address address;
+   * }
+	 * </pre>
+	 *
+	 * @return empty String by default.
+	 */
+	@AliasFor(annotation = CompoundIndex.class, attribute = "def")
+	String fields();
+
+	/**
+	 * Index name either as plain value or as {@link org.springframework.expression.spel.standard.SpelExpression template
+	 * expression}. <br />
+	 *
+	 * @return empty by default.
+	 */
+	@AliasFor(annotation = WildcardIndexed.class, attribute = "name")
+	String name() default "";
+
+	/**
+	 * If set to {@literal true} then MongoDB will ignore the given index name and instead generate a new name. Defaults
+	 * to {@literal false}.
+	 *
+	 * @return {@literal false} by default
+	 */
+	@AliasFor(annotation = WildcardIndexed.class, attribute = "useGeneratedName")
+	boolean useGeneratedName() default false;
+
+	/**
+	 * Only index the documents in a collection that meet a specified {@link IndexFilter filter expression}. <br />
+	 *
+	 * @return empty by default.
+	 */
+	@AliasFor(annotation = WildcardIndexed.class, attribute = "partialFilter")
+	String partialFilter() default "";
+
+	/**
+	 * Defines the collation to apply.
+	 *
+	 * @return an empty {@link String} by default.
+	 */
+	@AliasFor(annotation = WildcardIndexed.class, attribute = "collation")
+	String collation() default "";
+}

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/index/MongoPersistentEntityIndexResolver.java

@@ -79,6 +79,7 @@
  * @author Mark Paluch
  * @author Dave Perryman
  * @author Stefan Tirea
+ * @author Julia Lee
  * @since 1.5
  */
 public class MongoPersistentEntityIndexResolver implements IndexResolver {
@@ -129,6 +130,7 @@ public List<IndexDefinitionHolder> resolveIndexForEntity(MongoPersistentEntity<?
 		indexInformation.addAll(potentiallyCreateCompoundIndexDefinitions("", collection, root));
 		indexInformation.addAll(potentiallyCreateWildcardIndexDefinitions("", collection, root));
 		indexInformation.addAll(potentiallyCreateTextIndexDefinition(root, collection));
+		indexInformation.addAll(potentiallyCreateCompoundWildcardDefinition(root, collection));
 
 		root.doWithProperties((PropertyHandler<MongoPersistentProperty>) property -> this
 				.potentiallyAddIndexForProperty(root, property, indexInformation, new CycleGuard()));
@@ -154,6 +156,22 @@ private void verifyWildcardIndexedProjection(MongoPersistentEntity<?> entity) {
 				}
 			}
 		});
+
+		if (entity.isAnnotationPresent(CompoundWildcardIndexed.class)) {
+			CompoundWildcardIndexed indexed = entity.getRequiredAnnotation(CompoundWildcardIndexed.class);
+
+			if (!ObjectUtils.isEmpty(indexed.wildcardFieldName()) && !ObjectUtils.isEmpty(indexed.wildcardProjection())) {
+
+				throw new MappingException(
+						String.format("CompoundWildcardIndex.wildcardProjection is only allowed on \"$**\"; Offending property: %s",
+								indexed.wildcardFieldName()));
+			}
+
+			if (ObjectUtils.isEmpty(indexed.wildcardFieldName()) && ObjectUtils.isEmpty(indexed.wildcardProjection())) {
+
+				throw new MappingException(String.format("CompoundWildcardIndex.wildcardProjection is required on \"$**\""));
+			}
+		}
 	}
 
 	private void potentiallyAddIndexForProperty(MongoPersistentEntity<?> root, MongoPersistentProperty persistentProperty,
@@ -280,7 +298,8 @@ private List<IndexDefinitionHolder> createIndexDefinitionHolderForProperty(Strin
 	private List<IndexDefinitionHolder> potentiallyCreateCompoundIndexDefinitions(String dotPath, String collection,
 			MongoPersistentEntity<?> entity) {
 
-		if (entity.findAnnotation(CompoundIndexes.class) == null && entity.findAnnotation(CompoundIndex.class) == null) {
+		if ((!entity.isAnnotationPresent(CompoundIndexes.class) && !entity.isAnnotationPresent(CompoundIndex.class))
+				|| entity.isAnnotationPresent(CompoundWildcardIndexed.class)) {
 			return Collections.emptyList();
 		}
 
@@ -290,7 +309,8 @@ private List<IndexDefinitionHolder> potentiallyCreateCompoundIndexDefinitions(St
 	private List<IndexDefinitionHolder> potentiallyCreateWildcardIndexDefinitions(String dotPath, String collection,
 			MongoPersistentEntity<?> entity) {
 
-		if (!entity.isAnnotationPresent(WildcardIndexed.class)) {
+		if (!entity.isAnnotationPresent(WildcardIndexed.class)
+				|| entity.isAnnotationPresent(CompoundWildcardIndexed.class)) {
 			return Collections.emptyList();
 		}
 
@@ -345,6 +365,19 @@ private Collection<? extends IndexDefinitionHolder> potentiallyCreateTextIndexDe
 
 	}
 
+	private Collection<? extends IndexDefinitionHolder> potentiallyCreateCompoundWildcardDefinition(
+			MongoPersistentEntity<?> entity, String collection) {
+
+		if (!entity.isAnnotationPresent(CompoundWildcardIndexed.class)) {
+			return Collections.emptyList();
+		}
+
+		CompoundWildcardIndexed compoundWildcardIndex = entity.getRequiredAnnotation(CompoundWildcardIndexed.class);
+		IndexDefinitionHolder compoundWildcardIndexDefinition = createCompoundWildcardIndexDefinition(collection,
+				compoundWildcardIndex, entity);
+		return Collections.singletonList(compoundWildcardIndexDefinition);
+	}
+
 	private void appendTextIndexInformation(DotPath dotPath, Path path, TextIndexDefinitionBuilder indexDefinitionBuilder,
 			MongoPersistentEntity<?> entity, TextIndexIncludeOptions includeOptions, CycleGuard guard) {
 
@@ -483,6 +516,30 @@ protected IndexDefinitionHolder createWildcardIndexDefinition(String dotPath, St
 		return new IndexDefinitionHolder(dotPath, indexDefinition, collection);
 	}
 
+	protected IndexDefinitionHolder createCompoundWildcardIndexDefinition(String collection, CompoundWildcardIndexed index,
+			@Nullable MongoPersistentEntity<?> entity) {
+
+		String wildcardField = index.wildcardFieldName();
+		org.bson.Document indexKeys = resolveCompoundIndexKeyFromStringDefinition("", index.fields(), entity);
+
+		CompoundWildcardIndexDefinition indexDefinition = new CompoundWildcardIndexDefinition(wildcardField, indexKeys);
+
+		if (StringUtils.hasText(index.wildcardProjection()) && ObjectUtils.isEmpty(wildcardField)) {
+			indexDefinition.wildcardProjection(evaluateWildcardProjection(index.wildcardProjection(), entity));
+		}
+
+		if (StringUtils.hasText(index.partialFilter())) {
+			indexDefinition.partial(evaluatePartialFilter(index.partialFilter(), entity));
+		}
+
+		if (!index.useGeneratedName()) {
+			indexDefinition.named(pathAwareIndexName(index.name(), "", entity, null));
+		}
+
+		indexDefinition.collation(resolveCollation(index, entity));
+		return new IndexDefinitionHolder("", indexDefinition, collection);
+	}
+
 	private org.bson.Document resolveCompoundIndexKeyFromStringDefinition(String dotPath, String keyDefinitionString,
 			PersistentEntity<?, ?> entity) {