DATAREDIS-471 - Add support for partial updates.

We now allow partial update of domain types via PartialUpdate. The according expiration times and secondary index structures are updated accordingly.

In some cases it is not necessary to load and rewrite the entire entity just to set a new value within it. A session timestamp for last active time might be such a scenario where you just want to alter one property.
`PartialUpdate` allows to define `set`, `delete` actions on existing objects while taking care of updating potential expiration times of the entity itself as well as index structures.

.Sample Partial Update
====
[source,java]
----
PartialUpdate<Person> update = new PartialUpdate<Person>("e2c7dcee", Person.class)
  .set("firstname", "mat")                                                           <1>
  .set("address.city", "emond's field")                                              <2>
  .del("age");                                                                       <3>

template.update(update);

update = new PartialUpdate<Person>("e2c7dcee", Person.class)
  .set("address", new Address("caemlyn", "andor"))                                   <4>
  .set("attributes", singletonMap("eye-color", "grey"));                             <5>

template.update(update);

update = new PartialUpdate<Person>("e2c7dcee", Person.class)
  .refreshTtl(true);                                                                 <6>
  .set("expiration", 1000);

template.update(update);
----
<1> Set the simple property _firstname_ to _mat_
<2> Set the simple property _address.city_ to _emond's field_ without having to pass in the entire object. This does not work when a custom conversion is registered.
<3> Remove the property _age_.
<4> Set complex property _address_.
<5> Set a map/collection of values removes the previously existing map/collection and replaces the values with the given ones.
<6> Automatically update the server expiration time when altering time to live.
====

NOTE: Updating complex objects as well as map/collection structures requires further interaction with Redis to determine existing values which means that it might turn out that rewriting the entire entity might be faster.

Author: christophstrobl

src/main/asciidoc/reference/redis-repositories.adoc

@@ -487,6 +487,44 @@ mother = persons:a9d4b3a0-50d3-4538-a2fc-f7fc2581ee56      <1>
 WARNING: Referenced Objects are not subject of persisting changes when saving the referencing object. Please make sure to persist changes on referenced objects separately, since only the reference will be stored. 
 Indexes set on properties of referenced types will not be resolved.
 
+[[redis.repositories.partial-updates]]
+== Persisting Partial Updates
+In some cases it is not necessary to load and rewrite the entire entity just to set a new value within it. A session timestamp for last active time might be such a scenario where you just want to alter one property.
+`PartialUpdate` allows to define `set`, `delete` actions on existing objects while taking care of updating potential expiration times of the entity itself as well as index structures.
+
+.Sample Partial Update
+====
+[source,java]
+----
+PartialUpdate<Person> update = new PartialUpdate<Person>("e2c7dcee", Person.class)
+  .set("firstname", "mat")                                                           <1>
+  .set("address.city", "emond's field")                                              <2>
+  .del("age");                                                                       <3>
+
+template.update(update);
+
+update = new PartialUpdate<Person>("e2c7dcee", Person.class)
+  .set("address", new Address("caemlyn", "andor"))                                   <4>
+  .set("attributes", singletonMap("eye-color", "grey"));                             <5>
+
+template.update(update);
+
+update = new PartialUpdate<Person>("e2c7dcee", Person.class)
+  .refreshTtl(true);                                                                 <6>
+  .set("expiration", 1000);
+
+template.update(update);
+----
+<1> Set the simple property _firstname_ to _mat_
+<2> Set the simple property _address.city_ to _emond's field_ without having to pass in the entire object. This does not work when a custom conversion is registered.
+<3> Remove the property _age_.
+<4> Set complex property _address_.
+<5> Set a map/collection of values removes the previously existing map/collection and replaces the values with the given ones.
+<6> Automatically update the server expiration time when altering <<redis.repositories.expirations>>.
+====
+
+NOTE: Updating complex objects as well as map/collection structures requires further interaction with Redis to determine existing values which means that it might turn out that rewriting the entire entity might be faster.
+
 [[redis.repositories.queries]]
 == Queries and Query Methods
 Query methods allow automatic derivation of simple finder queries from the method name. 

src/main/java/org/springframework/data/redis/core/IndexWriter.java

@@ -21,6 +21,7 @@
 import org.springframework.data.redis.connection.RedisConnection;
 import org.springframework.data.redis.core.convert.IndexedData;
 import org.springframework.data.redis.core.convert.RedisConverter;
+import org.springframework.data.redis.core.convert.RemoveIndexedData;
 import org.springframework.data.redis.core.convert.SimpleIndexedPropertyValue;
 import org.springframework.data.redis.util.ByteUtils;
 import org.springframework.util.Assert;
@@ -123,8 +124,8 @@ private void removeKeyFromExistingIndexes(byte[] key, Iterable<IndexedData> inde
 	protected void removeKeyFromExistingIndexes(byte[] key, IndexedData indexedData) {
 
 		Assert.notNull(indexedData, "IndexedData must not be null!");
-		Set<byte[]> existingKeys = connection.keys(toBytes(indexedData.getKeyspace() + ":" + indexedData.getIndexName()
-				+ ":*"));
+		Set<byte[]> existingKeys = connection
+				.keys(toBytes(indexedData.getKeyspace() + ":" + indexedData.getIndexName() + ":*"));
 
 		if (!CollectionUtils.isEmpty(existingKeys)) {
 			for (byte[] existingKey : existingKeys) {
@@ -151,7 +152,11 @@ protected void addKeyToIndex(byte[] key, IndexedData indexedData) {
 		Assert.notNull(key, "Key must not be null!");
 		Assert.notNull(indexedData, "IndexedData must not be null!");
 
-		if (indexedData instanceof SimpleIndexedPropertyValue) {
+		if (indexedData instanceof RemoveIndexedData) {
+			return;
+		}
+
+		else if (indexedData instanceof SimpleIndexedPropertyValue) {
 
 			Object value = ((SimpleIndexedPropertyValue) indexedData).getValue();
 
@@ -166,8 +171,8 @@ protected void addKeyToIndex(byte[] key, IndexedData indexedData) {
 			// keep track of indexes used for the object
 			connection.sAdd(ByteUtils.concatAll(toBytes(indexedData.getKeyspace() + ":"), key, toBytes(":idx")), indexKey);
 		} else {
-			throw new IllegalArgumentException(String.format("Cannot write index data for unknown index type %s",
-					indexedData.getClass()));
+			throw new IllegalArgumentException(
+					String.format("Cannot write index data for unknown index type %s", indexedData.getClass()));
 		}
 	}
 
@@ -185,10 +190,8 @@ private byte[] toBytes(Object source) {
 			return converter.getConversionService().convert(source, byte[].class);
 		}
 
-		throw new InvalidDataAccessApiUsageException(
-				String
-						.format(
-								"Cannot convert %s to binary representation for index key generation. Are you missing a Converter? Did you register a non PathBasedRedisIndexDefinition that might apply to a complex type?",
-								source.getClass()));
+		throw new InvalidDataAccessApiUsageException(String.format(
+				"Cannot convert %s to binary representation for index key generation. Are you missing a Converter? Did you register a non PathBasedRedisIndexDefinition that might apply to a complex type?",
+				source.getClass()));
 	}
 }

src/main/java/org/springframework/data/redis/core/PartialUpdate.java

@@ -0,0 +1,236 @@
+/*
+ * 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.redis.core;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import org.springframework.util.Assert;
+import org.springframework.util.ClassUtils;
+
+/**
+ * {@link PartialUpdate} allows to issue individual property updates without the need of rewriting the whole entity. It
+ * allows to define {@literal set}, {@literal delete} actions on existing objects while taking care of updating
+ * potential expiration times of the entity itself as well as index structures.
+ *
+ * @author Christoph Strobl
+ * @param <T>
+ * @since 1.8
+ */
+public class PartialUpdate<T> {
+
+	private final Object id;
+	private final Class<T> target;
+	private final T value;
+	private boolean refreshTtl = false;
+
+	private final List<PropertyUpdate> propertyUpdates = new ArrayList<PropertyUpdate>();
+
+	private PartialUpdate(Object id, Class<T> target, T value, boolean refreshTtl, List<PropertyUpdate> propertyUpdates) {
+
+		this.id = id;
+		this.target = target;
+		this.value = value;
+		this.refreshTtl = refreshTtl;
+		this.propertyUpdates.addAll(propertyUpdates);
+	}
+
+	/**
+	 * Create new {@link PartialUpdate} for given id and type.
+	 *
+	 * @param id must not be {@literal null}.
+	 * @param targetType must not be {@literal null}.
+	 */
+	@SuppressWarnings("unchecked")
+	public PartialUpdate(Object id, Class<T> targetType) {
+
+		Assert.notNull(id, "Id must not be null!");
+		Assert.notNull(targetType, "TargetType must not be null!");
+
+		this.id = id;
+		this.target = (Class<T>) ClassUtils.getUserClass(targetType);
+		this.value = null;
+	}
+
+	/**
+	 * Create new {@link PartialUpdate} for given id and object.
+	 *
+	 * @param id must not be {@literal null}.
+	 * @param value must not be {@literal null}.
+	 */
+	@SuppressWarnings("unchecked")
+	public PartialUpdate(Object id, T value) {
+
+		Assert.notNull(id, "Id must not be null!");
+		Assert.notNull(value, "Value must not be null!");
+
+		this.id = id;
+		this.target = (Class<T>) ClassUtils.getUserClass(value.getClass());
+		this.value = value;
+	}
+
+	/**
+	 * Create new {@link PartialUpdate} for given id and type.
+	 *
+	 * @param id must not be {@literal null}.
+	 * @param targetType must not be {@literal null}.
+	 */
+	public static <S> PartialUpdate<S> newPartialUpdate(Object id, Class<S> targetType) {
+		return new PartialUpdate<S>(id, targetType);
+	}
+
+	/**
+	 * @return can be {@literal null}.
+	 */
+	public T getValue() {
+		return value;
+	}
+
+	/**
+	 * Set the value of a simple or complex {@literal value} reachable via given {@literal path}.
+	 *
+	 * @param path must not be {@literal null}.
+	 * @param value must not be {@literal null}. If you want to remove a value use {@link #del(String)}.
+	 * @return a new {@link PartialUpdate}.
+	 */
+	public PartialUpdate<T> set(String path, Object value) {
+
+		Assert.hasText(path, "Path to set must not be null or empty!");
+
+		PartialUpdate<T> update = new PartialUpdate<T>(this.id, this.target, this.value, this.refreshTtl,
+				this.propertyUpdates);
+		update.propertyUpdates.add(new PropertyUpdate(UpdateCommand.SET, path, value));
+		return update;
+	}
+
+	/**
+	 * Remove the value reachable via given {@literal path}.
+	 *
+	 * @param path path must not be {@literal null}.
+	 * @return a new {@link PartialUpdate}.
+	 */
+	public PartialUpdate<T> del(String path) {
+
+		Assert.hasText(path, "Path to remove must not be null or empty!");
+
+		PartialUpdate<T> update = new PartialUpdate<T>(this.id, this.target, this.value, this.refreshTtl,
+				this.propertyUpdates);
+		update.propertyUpdates.add(new PropertyUpdate(UpdateCommand.DEL, path));
+		return update;
+	}
+
+	/**
+	 * Get the target type.
+	 *
+	 * @return never {@literal null}.
+	 */
+	public Class<T> getTarget() {
+		return target;
+	}
+
+	/**
+	 * Get the id of the element to update.
+	 *
+	 * @return never {@literal null}.
+	 */
+	public Object getId() {
+		return id;
+	}
+
+	/**
+	 * Get the list of individual property updates.
+	 *
+	 * @return never {@literal null}.
+	 */
+	public List<PropertyUpdate> getPropertyUpdates() {
+		return Collections.unmodifiableList(propertyUpdates);
+	}
+
+	/**
+	 * @return true if expiration time of target should be updated.
+	 */
+	public boolean isRefreshTtl() {
+		return refreshTtl;
+	}
+
+	/**
+	 * Set indicator for updating expiration time of target.
+	 *
+	 * @param refreshTtl
+	 * @return a new {@link PartialUpdate}.
+	 */
+	public PartialUpdate<T> refreshTtl(boolean refreshTtl) {
+		return new PartialUpdate<T>(this.id, this.target, this.value, refreshTtl, this.propertyUpdates);
+	}
+
+	/**
+	 * @author Christoph Strobl
+	 * @since 1.8
+	 */
+	public static class PropertyUpdate {
+
+		private final UpdateCommand cmd;
+		private final String propertyPath;
+		private final Object value;
+
+		private PropertyUpdate(UpdateCommand cmd, String propertyPath) {
+			this(cmd, propertyPath, null);
+		}
+
+		private PropertyUpdate(UpdateCommand cmd, String propertyPath, Object value) {
+
+			this.cmd = cmd;
+			this.propertyPath = propertyPath;
+			this.value = value;
+		}
+
+		/**
+		 * Get the associated {@link UpdateCommand}.
+		 *
+		 * @return never {@literal null}.
+		 */
+		public UpdateCommand getCmd() {
+			return cmd;
+		}
+
+		/**
+		 * Get the target path.
+		 *
+		 * @return never {@literal null}.
+		 */
+		public String getPropertyPath() {
+			return propertyPath;
+		}
+
+		/**
+		 * Get the value to set.
+		 *
+		 * @return can be {@literal null}.
+		 */
+		public Object getValue() {
+			return value;
+		}
+	}
+
+	/**
+	 * @author Christoph Strobl
+	 * @since 1.8
+	 */
+	public static enum UpdateCommand {
+		SET, DEL
+	}
+}