DATAMONGO-1245 - Add support for Query By Example.

pom.xml

@@ -5,7 +5,7 @@
 
 	<groupId>org.springframework.data</groupId>
 	<artifactId>spring-data-mongodb-parent</artifactId>
-	<version>1.9.0.BUILD-SNAPSHOT</version>
+	<version>1.9.0.DATAMONGO-1245-SNAPSHOT</version>
 	<packaging>pom</packaging>
 
 	<name>Spring Data MongoDB</name>
@@ -28,7 +28,7 @@
 	<properties>
 		<project.type>multi</project.type>
 		<dist.id>spring-data-mongodb</dist.id>
-		<springdata.commons>1.12.0.BUILD-SNAPSHOT</springdata.commons>
+		<springdata.commons>1.12.0.DATACMNS-810-SNAPSHOT</springdata.commons>
 		<mongo>2.14.0</mongo>
 		<mongo.osgi>2.13.0</mongo.osgi>
 	</properties>

spring-data-mongodb-cross-store/pom.xml

@@ -6,7 +6,7 @@
 	<parent>
 		<groupId>org.springframework.data</groupId>
 		<artifactId>spring-data-mongodb-parent</artifactId>
-		<version>1.9.0.BUILD-SNAPSHOT</version>
+		<version>1.9.0.DATAMONGO-1245-SNAPSHOT</version>
 		<relativePath>../pom.xml</relativePath>
 	</parent>
 
@@ -48,7 +48,7 @@
 		<dependency>
 			<groupId>org.springframework.data</groupId>
 			<artifactId>spring-data-mongodb</artifactId>
-			<version>1.9.0.BUILD-SNAPSHOT</version>
+			<version>1.9.0.DATAMONGO-1245-SNAPSHOT</version>
 		</dependency>
 
 		<dependency>

spring-data-mongodb-distribution/pom.xml

@@ -13,7 +13,7 @@
 	<parent>
 		<groupId>org.springframework.data</groupId>
 		<artifactId>spring-data-mongodb-parent</artifactId>
-		<version>1.9.0.BUILD-SNAPSHOT</version>
+		<version>1.9.0.DATAMONGO-1245-SNAPSHOT</version>
 		<relativePath>../pom.xml</relativePath>
 	</parent>
 

spring-data-mongodb-log4j/pom.xml

@@ -5,7 +5,7 @@
 	<parent>
 		<groupId>org.springframework.data</groupId>
 		<artifactId>spring-data-mongodb-parent</artifactId>
-		<version>1.9.0.BUILD-SNAPSHOT</version>
+		<version>1.9.0.DATAMONGO-1245-SNAPSHOT</version>
 		<relativePath>../pom.xml</relativePath>
 	</parent>
 

spring-data-mongodb/pom.xml

@@ -11,7 +11,7 @@
 	<parent>
 		<groupId>org.springframework.data</groupId>
 		<artifactId>spring-data-mongodb-parent</artifactId>
-		<version>1.9.0.BUILD-SNAPSHOT</version>
+		<version>1.9.0.DATAMONGO-1245-SNAPSHOT</version>
 		<relativePath>../pom.xml</relativePath>
 	</parent>
 

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

@@ -117,6 +117,10 @@ public Point convert(DBObject source) {
 
 			Assert.isTrue(source.keySet().size() == 2, "Source must contain 2 elements");
 
+			if (source.containsField("type")) {
+				return DbObjectToGeoJsonPointConverter.INSTANCE.convert(source);
+			}
+
 			return new Point((Double) source.get("x"), (Double) source.get("y"));
 		}
 	}

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

@@ -0,0 +1,247 @@
+/*
+ * Copyright 2015-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.convert;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+import java.util.Stack;
+import java.util.regex.Pattern;
+
+import org.bson.BasicBSONObject;
+import org.springframework.data.domain.Example;
+import org.springframework.data.domain.ExampleSpec;
+import org.springframework.data.domain.ExampleSpec.NullHandler;
+import org.springframework.data.domain.ExampleSpec.PropertyValueTransformer;
+import org.springframework.data.domain.ExampleSpec.StringMatcher;
+import org.springframework.data.mapping.PropertyHandler;
+import org.springframework.data.mapping.context.MappingContext;
+import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
+import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty;
+import org.springframework.data.mongodb.core.query.MongoRegexCreator;
+import org.springframework.data.mongodb.core.query.SerializationUtils;
+import org.springframework.data.repository.core.support.ExampleSpecAccessor;
+import org.springframework.data.repository.query.parser.Part.Type;
+import org.springframework.util.ObjectUtils;
+import org.springframework.util.StringUtils;
+
+import com.mongodb.BasicDBObject;
+import com.mongodb.DBObject;
+
+/**
+ * @author Christoph Strobl
+ * @author Mark Paluch
+ * @since 1.8
+ */
+public class MongoExampleMapper {
+
+	private final MappingContext<? extends MongoPersistentEntity<?>, MongoPersistentProperty> mappingContext;
+	private final MongoConverter converter;
+	private final Map<StringMatcher, Type> stringMatcherPartMapping = new HashMap<StringMatcher, Type>();
+
+	public MongoExampleMapper(MongoConverter converter) {
+
+		this.converter = converter;
+		this.mappingContext = converter.getMappingContext();
+
+		stringMatcherPartMapping.put(StringMatcher.EXACT, Type.SIMPLE_PROPERTY);
+		stringMatcherPartMapping.put(StringMatcher.CONTAINING, Type.CONTAINING);
+		stringMatcherPartMapping.put(StringMatcher.STARTING, Type.STARTING_WITH);
+		stringMatcherPartMapping.put(StringMatcher.ENDING, Type.ENDING_WITH);
+		stringMatcherPartMapping.put(StringMatcher.REGEX, Type.REGEX);
+	}
+
+	/**
+	 * Returns the given {@link Example} as {@link DBObject} holding matching values extracted from
+	 * {@link Example#getProbe()}.
+	 *
+	 * @param example
+	 * @return
+	 * @since 1.8
+	 */
+	public DBObject getMappedExample(Example<?> example) {
+		return getMappedExample(example, mappingContext.getPersistentEntity(example.getProbeType()));
+	}
+
+	/**
+	 * Returns the given {@link Example} as {@link DBObject} holding matching values extracted from
+	 * {@link Example#getProbe()}.
+	 *
+	 * @param example
+	 * @param entity
+	 * @return
+	 * @since 1.8
+	 */
+	public DBObject getMappedExample(Example<?> example, MongoPersistentEntity<?> entity) {
+
+		DBObject reference = (DBObject) converter.convertToMongoType(example.getProbe());
+
+		if (entity.hasIdProperty() && entity.getIdentifierAccessor(example.getProbe()).getIdentifier() == null) {
+			reference.removeField(entity.getIdProperty().getFieldName());
+		}
+
+		ExampleSpecAccessor exampleSpecAccessor = new ExampleSpecAccessor(example.getExampleSpec());
+
+		applyPropertySpecs("", reference, example.getProbeType(), exampleSpecAccessor);
+
+		if (exampleSpecAccessor.isTyped()) {
+			this.converter.getTypeMapper().writeTypeRestrictions(reference, (Set) Collections.singleton(example.getResultType()));
+		}
+
+		return ObjectUtils.nullSafeEquals(NullHandler.INCLUDE, exampleSpecAccessor.getNullHandler()) ? reference
+				: new BasicDBObject(SerializationUtils.flattenMap(reference));
+	}
+
+	private String getMappedPropertyPath(String path, Class<?> probeType) {
+
+		MongoPersistentEntity<?> entity = mappingContext.getPersistentEntity(probeType);
+
+		Iterator<String> parts = Arrays.asList(path.split("\\.")).iterator();
+
+		final Stack<MongoPersistentProperty> stack = new Stack<MongoPersistentProperty>();
+
+		List<String> resultParts = new ArrayList<String>();
+
+		while (parts.hasNext()) {
+
+			final String part = parts.next();
+			MongoPersistentProperty prop = entity.getPersistentProperty(part);
+
+			if (prop == null) {
+
+				entity.doWithProperties(new PropertyHandler<MongoPersistentProperty>() {
+
+					@Override
+					public void doWithPersistentProperty(MongoPersistentProperty property) {
+
+						if (property.getFieldName().equals(part)) {
+							stack.push(property);
+						}
+					}
+				});
+
+				if (stack.isEmpty()) {
+					return "";
+				}
+				prop = stack.pop();
+			}
+
+			resultParts.add(prop.getName());
+
+			if (prop.isEntity() && mappingContext.hasPersistentEntityFor(prop.getActualType())) {
+				entity = mappingContext.getPersistentEntity(prop.getActualType());
+			} else {
+				break;
+			}
+		}
+
+		return StringUtils.collectionToDelimitedString(resultParts, ".");
+
+	}
+
+	private void applyPropertySpecs(String path, DBObject source, Class<?> probeType,
+			ExampleSpecAccessor exampleSpecAccessor) {
+
+		if (!(source instanceof BasicDBObject)) {
+			return;
+		}
+
+		Iterator<Map.Entry<String, Object>> iter = ((BasicDBObject) source).entrySet().iterator();
+
+		while (iter.hasNext()) {
+
+			Map.Entry<String, Object> entry = iter.next();
+			String propertyPath = StringUtils.hasText(path) ? path + "." + entry.getKey() : entry.getKey();
+			String mappedPropertyPath = getMappedPropertyPath(propertyPath, probeType);
+
+			if(isEmptyIdProperty(entry)) {
+				iter.remove();
+				continue;
+			}
+
+			if (exampleSpecAccessor.isIgnoredPath(propertyPath) || exampleSpecAccessor.isIgnoredPath(mappedPropertyPath)) {
+				iter.remove();
+				continue;
+			}
+
+			StringMatcher stringMatcher = exampleSpecAccessor.getDefaultStringMatcher();
+			Object value = entry.getValue();
+			boolean ignoreCase = exampleSpecAccessor.isIgnoreCaseEnabled();
+
+			if (exampleSpecAccessor.hasPropertySpecifiers()) {
+
+				mappedPropertyPath = exampleSpecAccessor.hasPropertySpecifier(propertyPath) ? propertyPath
+						: getMappedPropertyPath(propertyPath, probeType);
+
+				stringMatcher = exampleSpecAccessor.getStringMatcherForPath(mappedPropertyPath);
+				ignoreCase = exampleSpecAccessor.isIgnoreCaseForPath(mappedPropertyPath);
+			}
+
+			// TODO: should a PropertySpecifier outrule the later on string matching?
+			if (exampleSpecAccessor.hasPropertySpecifier(mappedPropertyPath)) {
+
+				PropertyValueTransformer valueTransformer = exampleSpecAccessor.getValueTransformerForPath(mappedPropertyPath);
+				value = valueTransformer.convert(value);
+				if (value == null) {
+					iter.remove();
+					continue;
+				}
+
+				entry.setValue(value);
+			}
+
+			if (entry.getValue() instanceof String) {
+				applyStringMatcher(entry, stringMatcher, ignoreCase);
+			} else if (entry.getValue() instanceof BasicDBObject) {
+				applyPropertySpecs(propertyPath, (BasicDBObject) entry.getValue(), probeType, exampleSpecAccessor);
+			}
+		}
+	}
+
+	private boolean isEmptyIdProperty(Entry<String, Object> entry) {
+		return entry.getKey().equals("_id") && entry.getValue() == null;
+	}
+
+	private void applyStringMatcher(Map.Entry<String, Object> entry, StringMatcher stringMatcher, boolean ignoreCase) {
+
+		BasicDBObject dbo = new BasicDBObject();
+
+		if (ObjectUtils.nullSafeEquals(StringMatcher.DEFAULT, stringMatcher)) {
+
+			if (ignoreCase) {
+				dbo.put("$regex", Pattern.quote((String) entry.getValue()));
+				entry.setValue(dbo);
+			}
+		} else {
+
+			Type type = stringMatcherPartMapping.get(stringMatcher);
+			String expression = MongoRegexCreator.INSTANCE.toRegularExpression((String) entry.getValue(), type);
+			dbo.put("$regex", expression);
+			entry.setValue(dbo);
+		}
+
+		if (ignoreCase) {
+			dbo.put("$options", "i");
+		}
+	}
+
+}

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

@@ -27,6 +27,7 @@
 import org.springframework.core.convert.ConversionException;
 import org.springframework.core.convert.ConversionService;
 import org.springframework.core.convert.converter.Converter;
+import org.springframework.data.domain.Example;
 import org.springframework.data.mapping.Association;
 import org.springframework.data.mapping.PersistentEntity;
 import org.springframework.data.mapping.PropertyPath;
@@ -70,6 +71,7 @@ private enum MetaMapping {
 	private final ConversionService conversionService;
 	private final MongoConverter converter;
 	private final MappingContext<? extends MongoPersistentEntity<?>, MongoPersistentProperty> mappingContext;
+	private final MongoExampleMapper exampleMapper;
 
 	/**
 	 * Creates a new {@link QueryMapper} with the given {@link MongoConverter}.
@@ -83,6 +85,7 @@ public QueryMapper(MongoConverter converter) {
 		this.conversionService = converter.getConversionService();
 		this.converter = converter;
 		this.mappingContext = converter.getMappingContext();
+		this.exampleMapper = new MongoExampleMapper(converter);
 	}
 
 	/**
@@ -239,6 +242,10 @@ protected DBObject getMappedKeyword(Keyword keyword, MongoPersistentEntity<?> en
 			return new BasicDBObject(keyword.getKey(), newConditions);
 		}
 
+		if (keyword.isSample()) {
+			return exampleMapper.getMappedExample(keyword.<Example<?>> getValue(), entity);
+		}
+
 		return new BasicDBObject(keyword.getKey(), convertSimpleOrDBObject(keyword.getValue(), entity));
 	}
 
@@ -566,6 +573,16 @@ public boolean isGeometry() {
 			return "$geometry".equalsIgnoreCase(key);
 		}
 
+		/**
+		 * Returns wheter the current keyword indicates a sample object.
+		 * 
+		 * @return
+		 * @since 1.8
+		 */
+		public boolean isSample() {
+			return "$sample".equalsIgnoreCase(key);
+		}
+
 		public boolean hasIterableValue() {
 			return value instanceof Iterable;
 		}