DATAMONGO-1467 - Add support for MongoDB 3.2 partialFilterExpression for index creation.

We now support partial filter expression on indexes via Index.partial(…). This allows to create partial indexes that only index the documents in a collection that meet a specified filter expression.

new Index().named("idx").on("k3y", ASC).partial(filter(where("age").gte(10)))

The filter expression can be set via a plain DBObject or a CriteriaDefinition and is mapped against the associated domain type.

Original pull request: #431.

Author: christophstrobl

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/config/MappingMongoConverterParser.java

@@ -55,6 +55,7 @@
 import org.springframework.data.mapping.model.CamelCaseAbbreviatingFieldNamingStrategy;
 import org.springframework.data.mongodb.core.convert.CustomConversions;
 import org.springframework.data.mongodb.core.convert.MappingMongoConverter;
+import org.springframework.data.mongodb.core.convert.QueryMapper;
 import org.springframework.data.mongodb.core.index.MongoPersistentEntityIndexCreator;
 import org.springframework.data.mongodb.core.mapping.Document;
 import org.springframework.data.mongodb.core.mapping.MongoMappingContext;
@@ -125,6 +126,7 @@ public BeanDefinition parse(Element element, ParserContext parserContext) {
 
 			BeanDefinitionBuilder indexOperationsProviderBuilder = BeanDefinitionBuilder.genericBeanDefinition("org.springframework.data.mongodb.core.DefaultIndexOperationsProvider");
 			indexOperationsProviderBuilder.addConstructorArgReference(dbFactoryRef);
+			indexOperationsProviderBuilder.addConstructorArgValue(BeanDefinitionBuilder.genericBeanDefinition(QueryMapper.class).addConstructorArgReference(id).getBeanDefinition());
 			parserContext.registerBeanComponent(new BeanComponentDefinition(indexOperationsProviderBuilder.getBeanDefinition(), "indexOperationsProvider"));
 		}
 

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

@@ -18,13 +18,17 @@
 import static org.springframework.data.mongodb.core.MongoTemplate.*;
 
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
 import java.util.List;
 
 import org.bson.Document;
 import org.springframework.dao.DataAccessException;
+import org.springframework.data.mongodb.core.convert.QueryMapper;
 import org.springframework.data.mongodb.MongoDbFactory;
 import org.springframework.data.mongodb.core.index.IndexDefinition;
 import org.springframework.data.mongodb.core.index.IndexInfo;
+import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
 import org.springframework.util.Assert;
 
 import com.mongodb.MongoException;
@@ -43,22 +47,45 @@
  */
 public class DefaultIndexOperations implements IndexOperations {
 
+	public static final String PARTIAL_FILTER_EXPRESSION_KEY = "partialFilterExpression";
+
 	private final MongoDbFactory mongoDbFactory;
 	private final String collectionName;
+	private final QueryMapper mapper;
+	private final Class<?> type;
 
 	/**
 	 * Creates a new {@link DefaultIndexOperations}.
 	 * 
 	 * @param mongoDbFactory must not be {@literal null}.
 	 * @param collectionName must not be {@literal null}.
+	 * @param queryMapper must not be {@literal null}.
 	 */
-	public DefaultIndexOperations(MongoDbFactory mongoDbFactory, String collectionName) {
+	public DefaultIndexOperations(MongoDbFactory mongoDbFactory, String collectionName, QueryMapper queryMapper) {
+
+		this(mongoDbFactory, collectionName, queryMapper, null);
+	}
+
+	/**
+	 * Creates a new {@link DefaultIndexOperations}.
+	 *
+	 * @param mongoDbFactory must not be {@literal null}.
+	 * @param collectionName must not be {@literal null}.
+	 * @param queryMapper must not be {@literal null}.
+	 * @param type Type used for mapping potential partial index filter expression. Can be {@literal null}.
+	 * @since 1.10
+	 */
+	public DefaultIndexOperations(MongoDbFactory mongoDbFactory, String collectionName, QueryMapper queryMapper,
+			Class<?> type) {
 
 		Assert.notNull(mongoDbFactory, "MongoDbFactory must not be null!");
 		Assert.notNull(collectionName, "Collection name can not be null!");
+		Assert.notNull(queryMapper, "QueryMapper must not be null!");
 
 		this.mongoDbFactory = mongoDbFactory;
 		this.collectionName = collectionName;
+		this.mapper = queryMapper;
+		this.type = type;
 	}
 
 	/*
@@ -74,10 +101,38 @@ public String ensureIndex(final IndexDefinition indexDefinition) {
 			if (indexOptions != null) {
 
 				IndexOptions ops = IndexConverters.indexDefinitionToIndexOptionsConverter().convert(indexDefinition);
+
+				if (indexOptions.containsKey(PARTIAL_FILTER_EXPRESSION_KEY)) {
+
+					Assert.isInstanceOf(Document.class, indexOptions.get(PARTIAL_FILTER_EXPRESSION_KEY));
+
+					ops.partialFilterExpression( mapper.getMappedObject(
+							(Document) indexOptions.get(PARTIAL_FILTER_EXPRESSION_KEY), lookupPersistentEntity(type, collectionName)));
+				}
+
 				return collection.createIndex(indexDefinition.getIndexKeys(), ops);
 			}
 			return collection.createIndex(indexDefinition.getIndexKeys());
-		});
+		}
+
+		);
+	}
+
+	private MongoPersistentEntity<?> lookupPersistentEntity(Class<?> entityType, String collection) {
+
+		if (entityType != null) {
+			return mapper.getMappingContext().getPersistentEntity(entityType);
+		}
+
+		Collection<? extends MongoPersistentEntity<?>> entities = mapper.getMappingContext().getPersistentEntities();
+
+		for (MongoPersistentEntity<?> entity : entities) {
+			if (entity.getCollection().equals(collection)) {
+				return entity;
+			}
+		}
+
+		return null;
 	}
 
 	/*

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

@@ -16,6 +16,7 @@
 package org.springframework.data.mongodb.core;
 
 import org.springframework.data.mongodb.MongoDbFactory;
+import org.springframework.data.mongodb.core.convert.QueryMapper;
 
 /**
  * {@link IndexOperationsProvider} to obtain {@link IndexOperations} from a given {@link MongoDbFactory}. TODO: Review
@@ -27,19 +28,20 @@
 class DefaultIndexOperationsProvider implements IndexOperationsProvider {
 
 	private final MongoDbFactory mongoDbFactory;
+	private final QueryMapper mapper;
 
 	/**
 	 * @param mongoDbFactory must not be {@literal null}.
 	 */
-	DefaultIndexOperationsProvider(MongoDbFactory mongoDbFactory) {
-		this.mongoDbFactory = mongoDbFactory;
+	DefaultIndexOperationsProvider(MongoDbFactory mongoDbFactory, QueryMapper mapper) {
+		this.mongoDbFactory = mongoDbFactory; this.mapper = mapper;
 	}
 
 	/* (non-Javadoc)
 	 * @see org.springframework.data.mongodb.core.IndexOperationsProvider#reactiveIndexOps(java.lang.String)
 	 */
 	@Override
 	public IndexOperations indexOps(String collectionName) {
-		return new DefaultIndexOperations(mongoDbFactory, collectionName);
+		return new DefaultIndexOperations(mongoDbFactory, collectionName, mapper);
 	}
 }

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

@@ -117,50 +117,18 @@ private static Converter<IndexDefinition, IndexOptions> getIndexDefinitionIndexO
 				}
 			}
 
+			if(indexOptions.containsKey("partialFilterExpression")) {
+				ops = ops.partialFilterExpression((org.bson.Document)indexOptions.get("partialFilterExpression"));
+			}
+
 			return ops;
 		};
 	}
 
 	private static Converter<Document, IndexInfo> getDocumentIndexInfoConverter() {
 
 		return ix -> {
-			Document keyDocument = (Document) ix.get("key");
-			int numberOfElements = keyDocument.keySet().size();
-
-			List<IndexField> indexFields = new ArrayList<IndexField>(numberOfElements);
-
-			for (String key : keyDocument.keySet()) {
-
-				Object value = keyDocument.get(key);
-
-				if (TWO_D_IDENTIFIERS.contains(value)) {
-					indexFields.add(IndexField.geo(key));
-				} else if ("text".equals(value)) {
-
-					Document weights = (Document) ix.get("weights");
-					for (String fieldName : weights.keySet()) {
-						indexFields.add(IndexField.text(fieldName, Float.valueOf(weights.get(fieldName).toString())));
-					}
-
-				} else {
-
-					Double keyValue = new Double(value.toString());
-
-					if (ONE.equals(keyValue)) {
-						indexFields.add(IndexField.create(key, ASC));
-					} else if (MINUS_ONE.equals(keyValue)) {
-						indexFields.add(IndexField.create(key, DESC));
-					}
-				}
-			}
-
-			String name = ix.get("name").toString();
-
-			boolean unique = ix.containsKey("unique") ? (Boolean) ix.get("unique") : false;
-			boolean sparse = ix.containsKey("sparse") ? (Boolean) ix.get("sparse") : false;
-
-			String language = ix.containsKey("default_language") ? (String) ix.get("default_language") : "";
-			return new IndexInfo(indexFields, name, unique, sparse, language);
+			return IndexInfo.indexInfoOf(ix);
 		};
 	}
 }

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

@@ -16,6 +16,8 @@
 
 package org.springframework.data.mongodb.core;
 
+import org.springframework.data.mongodb.core.convert.QueryMapper;
+
 /**
  * TODO: Revisit for a better pattern.
  * @author Mark Paluch

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

@@ -539,11 +539,11 @@ public Void doInCollection(MongoCollection<Document> collection) throws MongoExc
 	}
 
 	public IndexOperations indexOps(String collectionName) {
-		return new DefaultIndexOperations(getMongoDbFactory(), collectionName);
+		return new DefaultIndexOperations(getMongoDbFactory(), collectionName, queryMapper);
 	}
 
 	public IndexOperations indexOps(Class<?> entityClass) {
-		return new DefaultIndexOperations(getMongoDbFactory(), determineCollectionName(entityClass));
+		return new DefaultIndexOperations(getMongoDbFactory(), determineCollectionName(entityClass), queryMapper);
 	}
 
 	public BulkOperations bulkOps(BulkMode bulkMode, String collectionName) {
@@ -2176,7 +2176,7 @@ static RuntimeException potentiallyConvertRuntimeException(RuntimeException ex,
 	 * 
 	 * @param ids
 	 * @param documents
-	 * @return 
+	 * @return
 	 * TODO: Remove for 2.0 and change method signature of {@link #insertDBObjectList(String, List)}.
 	 */
 	private static List<Object> consolidateIdentifiers(List<ObjectId> ids, List<Document> documents) {

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/convert/QueryMapper.java

@@ -1092,4 +1092,8 @@ public String convert(MongoPersistentProperty source) {
 			return source.getFieldName();
 		}
 	}
+
+	public MappingContext<? extends MongoPersistentEntity<?>, MongoPersistentProperty> getMappingContext() {
+		return mappingContext;
+	}
 }

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

@@ -37,6 +37,7 @@ public class GeospatialIndex implements IndexDefinition {
 	private GeoSpatialIndexType type = GeoSpatialIndexType.GEO_2D;
 	private Double bucketSize = 1.0;
 	private String additionalField;
+	private IndexFilter filter;
 
 	/**
 	 * Creates a new {@link GeospatialIndex} for the given field.
@@ -117,6 +118,21 @@ public GeospatialIndex withAdditionalField(String fieldName) {
 		return this;
 	}
 
+	/**
+	 * Only index the documents in a collection that meet a specified {@link IndexFilter filter expression}.
+	 *
+	 * @param filter can be {@literal null}.
+	 * @return
+	 * @see <a href=
+	 *      "https://docs.mongodb.com/manual/core/index-partial/">https://docs.mongodb.com/manual/core/index-partial/</a>
+	 * @since 1.10
+	 */
+	public GeospatialIndex partial(IndexFilter filter) {
+
+		this.filter = filter;
+		return this;
+	}
+
 	public Document getIndexKeys() {
 
 		Document document = new Document();
@@ -184,6 +200,10 @@ public Document getIndexOptions() {
 				break;
 		}
 
+		if (filter != null) {
+			dbo.put("partialFilterExpression", filter.getFilterObject());
+		}
+
 		return dbo;
 	}
 

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

@@ -50,6 +50,8 @@ public enum Duplicates {
 
 	private long expire = -1;
 
+	private IndexFilter filter;
+
 	public Index() {}
 
 	public Index(String key, Direction direction) {
@@ -126,6 +128,21 @@ public Index expire(long value, TimeUnit unit) {
 		return this;
 	}
 
+	/**
+	 * Only index the documents in a collection that meet a specified {@link IndexFilter filter expression}.
+	 *
+	 * @param filter can be {@literal null}.
+	 * @return
+	 * @see <a href=
+	 *      "https://docs.mongodb.com/manual/core/index-partial/">https://docs.mongodb.com/manual/core/index-partial/</a>
+	 * @since 1.10
+	 */
+	public Index partial(IndexFilter filter) {
+
+		this.filter = filter;
+		return this;
+	}
+
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.mongodb.core.index.IndexDefinition#getIndexKeys()
@@ -163,6 +180,9 @@ public Document getIndexOptions() {
 			document.put("expireAfterSeconds", expire);
 		}
 
+		if (filter != null) {
+			document.put("partialFilterExpression", filter.getFilterObject());
+		}
 		return document;
 	}
 

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

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2016. 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
+ *
+ *      http://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;
+
+/**
+ * Use {@link IndexFilter} to create the partial filter expression used when creating
+ * <a href="https://docs.mongodb.com/manual/core/index-partial/">Partial Indexes</a>.
+ *
+ * @author Christoph Strobl
+ * @since 1.10
+ */
+public interface IndexFilter {
+
+	/**
+	 * Get the raw (unmapped) filter expression.
+	 *
+	 * @return
+	 */
+	Document getFilterObject();
+
+}