diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/mapping/PropertyPath.java b/spring-data-commons-core/src/main/java/org/springframework/data/mapping/PropertyPath.java
index 6daba9ad5..6cca43841 100644
--- a/spring-data-commons-core/src/main/java/org/springframework/data/mapping/PropertyPath.java
+++ b/spring-data-commons-core/src/main/java/org/springframework/data/mapping/PropertyPath.java
@@ -149,7 +149,7 @@ public class PropertyPath implements Iterable<PropertyPath> {
 	}
 
 	/**
-	 * Returns the {@link PropertyPath} path in dot notation.
+	 * Returns the {@link PropertyPath} in dot notation.
 	 * 
 	 * @return
 	 */
diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/mapping/context/DefaultPersistentPropertyPath.java b/spring-data-commons-core/src/main/java/org/springframework/data/mapping/context/DefaultPersistentPropertyPath.java
index 759b3192b..fd4ce11c3 100644
--- a/spring-data-commons-core/src/main/java/org/springframework/data/mapping/context/DefaultPersistentPropertyPath.java
+++ b/spring-data-commons-core/src/main/java/org/springframework/data/mapping/context/DefaultPersistentPropertyPath.java
@@ -26,50 +26,144 @@ import org.springframework.util.StringUtils;
 
 /**
  * Abstraction of a path of {@link PersistentProperty}s.
- *
+ * 
  * @author Oliver Gierke
  */
 class DefaultPersistentPropertyPath<T extends PersistentProperty<T>> implements PersistentPropertyPath<T> {
-	
-	private final Iterable<T> properties;
+
+	private enum PropertyNameConverter implements Converter<PersistentProperty<?>, String> {
+
+		INSTANCE;
+
+		public String convert(PersistentProperty<?> source) {
+			return source.getName();
+		}
+	}
+
+	private final List<T> properties;
 
 	/**
 	 * Creates a new {@link DefaultPersistentPropertyPath} for the given {@link PersistentProperty}s.
 	 * 
 	 * @param properties must not be {@literal null}.
 	 */
-	public DefaultPersistentPropertyPath(Iterable<T> properties) {
+	public DefaultPersistentPropertyPath(List<T> properties) {
 		Assert.notNull(properties);
+		Assert.isTrue(!properties.isEmpty());
 		this.properties = properties;
 	}
-	
+
 	/* 
 	 * (non-Javadoc)
 	 * @see org.springframework.data.mapping.context.PersistentPropertyPath#toDotPath()
 	 */
 	public String toDotPath() {
-		return toDotPath(new Converter<T, String>() {
-			public String convert(T source) {
-				return source.getName();
-			}
-		});
+		return toPath(null, null);
 	}
-	
+
 	/* 
 	 * (non-Javadoc)
 	 * @see org.springframework.data.mapping.context.PersistentPropertyPath#toDotPath(org.springframework.core.convert.converter.Converter)
 	 */
 	public String toDotPath(Converter<? super T, String> converter) {
-		
+		return toPath(null, converter);
+	}
+
+	/* 
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mapping.context.PersistentPropertyPath#toPath(java.lang.String)
+	 */
+	public String toPath(String delimiter) {
+		return toPath(delimiter, null);
+	}
+
+	/* 
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mapping.context.PersistentPropertyPath#toPath(java.lang.String, org.springframework.core.convert.converter.Converter)
+	 */
+	public String toPath(String delimiter, Converter<? super T, String> converter) {
+
+		@SuppressWarnings("unchecked")
+		Converter<? super T, String> converterToUse = (Converter<? super T, String>) (converter == null ? PropertyNameConverter.INSTANCE
+				: converter);
+		String delimiterToUse = delimiter == null ? "." : delimiter;
+
 		List<String> result = new ArrayList<String>();
-		
+
 		for (T property : properties) {
-			result.add(converter.convert(property));
+			result.add(converterToUse.convert(property));
 		}
-		
-		return StringUtils.collectionToDelimitedString(result, ".");
+
+		return StringUtils.collectionToDelimitedString(result, delimiterToUse);
 	}
-	
+
+	/* 
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mapping.context.PersistentPropertyPath#getLeafProperty()
+	 */
+	public T getLeafProperty() {
+		return properties.get(properties.size() - 1);
+	}
+
+	/* 
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mapping.context.PersistentPropertyPath#getBaseProperty()
+	 */
+	public T getBaseProperty() {
+		return properties.get(0);
+	}
+
+	/* 
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mapping.context.PersistentPropertyPath#isBasePathOf(org.springframework.data.mapping.context.PersistentPropertyPath)
+	 */
+	public boolean isBasePathOf(PersistentPropertyPath<T> path) {
+
+		if (path == null) {
+			return false;
+		}
+
+		Iterator<T> iterator = path.iterator();
+
+		for (T property : this) {
+
+			if (!iterator.hasNext()) {
+				return false;
+			}
+
+			T reference = iterator.next();
+
+			if (!property.equals(reference)) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	/* (non-Javadoc)
+	 * @see org.springframework.data.mapping.context.PersistentPropertyPath#getExtensionForBaseOf(org.springframework.data.mapping.context.PersistentPropertyPath)
+	 */
+	public PersistentPropertyPath<T> getExtensionForBaseOf(PersistentPropertyPath<T> base) {
+
+		if (!base.isBasePathOf(this)) {
+			return this;
+		}
+
+		List<T> properties = new ArrayList<T>();
+		Iterator<T> iterator = iterator();
+
+		for (@SuppressWarnings("unused") T candidate : base) {
+			iterator.next();
+		}
+
+		while (iterator.hasNext()) {
+			properties.add(iterator.next());
+		}
+
+		return new DefaultPersistentPropertyPath<T>(properties);
+	}
+
 	/* 
 	 * (non-Javadoc)
 	 * @see java.lang.Iterable#iterator()
@@ -77,27 +171,27 @@ class DefaultPersistentPropertyPath<T extends PersistentProperty<T>> implements
 	public Iterator<T> iterator() {
 		return properties.iterator();
 	}
-	
+
 	/* 
 	 * (non-Javadoc)
 	 * @see java.lang.Object#equals(java.lang.Object)
 	 */
 	@Override
 	public boolean equals(Object obj) {
-		
+
 		if (this == obj) {
 			return true;
 		}
-		
+
 		if (obj == null || !getClass().equals(obj.getClass())) {
 			return false;
 		}
-		
+
 		DefaultPersistentPropertyPath<?> that = (DefaultPersistentPropertyPath<?>) obj;
-		
+
 		return this.properties.equals(that.properties);
 	}
-	
+
 	/* 
 	 * (non-Javadoc)
 	 * @see java.lang.Object#hashCode()
diff --git a/spring-data-commons-core/src/main/java/org/springframework/data/mapping/context/PersistentPropertyPath.java b/spring-data-commons-core/src/main/java/org/springframework/data/mapping/context/PersistentPropertyPath.java
index aca089213..4cfe13c5c 100644
--- a/spring-data-commons-core/src/main/java/org/springframework/data/mapping/context/PersistentPropertyPath.java
+++ b/spring-data-commons-core/src/main/java/org/springframework/data/mapping/context/PersistentPropertyPath.java
@@ -15,20 +15,18 @@
  */
 package org.springframework.data.mapping.context;
 
-import java.util.Iterator;
-
 import org.springframework.core.convert.converter.Converter;
 import org.springframework.data.mapping.PersistentProperty;
 
 /**
  * Abstraction of a path of {@link PersistentProperty}s.
- *
+ * 
  * @author Oliver Gierke
  */
 public interface PersistentPropertyPath<T extends PersistentProperty<T>> extends Iterable<T> {
 
 	/**
-	 * Returns the dot based path notation using the {@link PersistentProperty}'s name attribute.
+	 * Returns the dot based path notation using {@link PersistentProperty#getName()}.
 	 * 
 	 * @return
 	 */
@@ -43,9 +41,58 @@ public interface PersistentPropertyPath<T extends PersistentProperty<T>> extends
 	 */
 	String toDotPath(Converter<? super T, String> converter);
 
-	/* 
-	 * (non-Javadoc)
-	 * @see java.lang.Iterable#iterator()
+	/**
+	 * Returns a {@link String} path with the given delimiter based on the {@link PersistentProperty#getName()}.
+	 * 
+	 * @param delimiter will default to {@code .} if {@literal null} is given.
+	 * @return
+	 */
+	String toPath(String delimiter);
+
+	/**
+	 * Returns a {@link String} path with the given delimiter using the given {@link Converter} for
+	 * {@link PersistentProperty} to String conversion.
+	 * 
+	 * @param delimiter will default to {@code .} if {@literal null} is given.
+	 * @param converter will default to use {@link PersistentProperty#getName()}.
+	 * @return
+	 */
+	String toPath(String delimiter, Converter<? super T, String> converter);
+
+	/**
+	 * Returns the last property in the {@link PersistentPropertyPath}. So for {@code foo.bar} it will return the
+	 * {@link PersistentProperty} for {@code bar}. For a simple {@code foo} it returns {@link PersistentProperty} for
+	 * {@code foo}.
+	 * 
+	 * @return
+	 */
+	T getLeafProperty();
+
+	/**
+	 * Returns the first property in the {@link PersistentPropertyPath}. So for {@code foo.bar} it will return the
+	 * {@link PersistentProperty} for {@code foo}. For a simple {@code foo} it returns {@link PersistentProperty} for
+	 * {@code foo}.
+	 * 
+	 * @return
+	 */
+	T getBaseProperty();
+
+	/**
+	 * Returns whether the given {@link PersistentPropertyPath} is a base path of the current one. This means that the
+	 * current {@link PersistentPropertyPath} is basically an extension of the given one.
+	 * 
+	 * @param path
+	 * @return
+	 */
+	boolean isBasePathOf(PersistentPropertyPath<T> path);
+
+	/**
+	 * Returns the sub-path of the current one as if it was based on the given base path. So for a current path
+	 * {@code foo.bar} and a given base {@code foo} it would return {@code bar}. If the given path is not a base of the
+	 * the current one the current {@link PersistentPropertyPath} will be returned as is.
+	 * 
+	 * @param base
+	 * @return
 	 */
-	Iterator<T> iterator();
+	PersistentPropertyPath<T> getExtensionForBaseOf(PersistentPropertyPath<T> base);
 }
\ No newline at end of file
diff --git a/spring-data-commons-core/src/test/java/org/springframework/data/mapping/context/DefaultPersistenPropertyPathUnitTest.java b/spring-data-commons-core/src/test/java/org/springframework/data/mapping/context/DefaultPersistenPropertyPathUnitTest.java
index 2279229c9..3644d5b20 100644
--- a/spring-data-commons-core/src/test/java/org/springframework/data/mapping/context/DefaultPersistenPropertyPathUnitTest.java
+++ b/spring-data-commons-core/src/test/java/org/springframework/data/mapping/context/DefaultPersistenPropertyPathUnitTest.java
@@ -22,6 +22,7 @@ import static org.mockito.Mockito.*;
 
 import java.util.Arrays;
 
+import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
@@ -43,6 +44,16 @@ public class DefaultPersistenPropertyPathUnitTest<T extends PersistentProperty<T
 
 	@Mock
 	Converter<T, String> converter;
+	
+	PersistentPropertyPath<T> oneLeg;
+	PersistentPropertyPath<T> twoLegs;
+	
+	@Before
+	@SuppressWarnings("unchecked")
+	public void setUp() {
+		oneLeg = new DefaultPersistentPropertyPath<T>(Arrays.asList(first));
+		twoLegs = new DefaultPersistentPropertyPath<T>(Arrays.asList(first, second));
+	}
 
 	@Test(expected = IllegalArgumentException.class)
 	public void rejectsNullProperties() {
@@ -50,14 +61,12 @@ public class DefaultPersistenPropertyPathUnitTest<T extends PersistentProperty<T
 	}
 
 	@Test
-	@SuppressWarnings("unchecked")
 	public void usesPropertyNameForSimpleDotPath() {
 
 		when(first.getName()).thenReturn("foo");
 		when(second.getName()).thenReturn("bar");
 
-		PersistentPropertyPath<T> path = new DefaultPersistentPropertyPath<T>(Arrays.asList(first, second));
-		assertThat(path.toDotPath(), is("foo.bar"));
+		assertThat(twoLegs.toDotPath(), is("foo.bar"));
 	}
 
 	@Test
@@ -66,7 +75,35 @@ public class DefaultPersistenPropertyPathUnitTest<T extends PersistentProperty<T
 
 		when(converter.convert((T) any())).thenReturn("foo");
 
-		PersistentPropertyPath<T> path = new DefaultPersistentPropertyPath<T>(Arrays.asList(first, second));
-		assertThat(path.toDotPath(converter), is("foo.foo"));
+		assertThat(twoLegs.toDotPath(converter), is("foo.foo"));
+	}
+
+	@Test
+	public void returnsCorrectLeafProperty() {
+
+		assertThat(twoLegs.getLeafProperty(), is(second));
+		assertThat(oneLeg.getLeafProperty(), is(first));
+	}
+	
+	@Test
+	public void returnsCorrectBaseProperty() {
+
+		assertThat(twoLegs.getBaseProperty(), is(first));
+		assertThat(oneLeg.getBaseProperty(), is(first));
+	}
+
+	@Test
+	public void detectsBasePathCorrectly() {
+
+		assertThat(oneLeg.isBasePathOf(twoLegs), is(true));
+		assertThat(twoLegs.isBasePathOf(oneLeg), is(false));
+	}
+	
+	@Test
+	@SuppressWarnings("unchecked")
+	public void calculatesExtensionCorrectly() {
+		
+		PersistentPropertyPath<T> extension = twoLegs.getExtensionForBaseOf(oneLeg);
+		assertThat(extension, is((PersistentPropertyPath<T>) new DefaultPersistentPropertyPath<T>(Arrays.asList(second))));
 	}
 }