Support slice in delete by query (#3014)

Closes #2859

Author: russcam

src/Nest/Document/Multiple/DeleteByQuery/DeleteByQueryRequest.cs

@@ -3,36 +3,75 @@
 
 namespace Nest
 {
+	/// <summary>
+	/// Delete documents that match a given query
+	/// </summary>
 	public partial interface IDeleteByQueryRequest
 	{
+		/// <summary>
+		/// The query to use to select documents for deletion
+		/// </summary>
 		[JsonProperty("query")]
 		QueryContainer Query { get; set; }
+
+		/// <summary>
+		/// Parallelize the deleting process. This parallelization can improve efficiency and
+		/// provide a convenient way to break the request down into smaller parts.
+		/// </summary>
+		[JsonProperty("slice")]
+		ISlicedScroll Slice { get; set; }
 	}
 
+	/// <inheritdoc />
 	public interface IDeleteByQueryRequest<T> : IDeleteByQueryRequest where T : class { }
 
+	/// <inheritdoc cref="IDeleteByQueryRequest"/>
 	public partial class DeleteByQueryRequest
 	{
+		/// <inheritdoc />
 		public QueryContainer Query { get; set; }
 
+		/// <inheritdoc />
+		public ISlicedScroll Slice { get; set; }
 	}
 
+	/// <inheritdoc cref="IDeleteByQueryRequest"/>
 	public partial class DeleteByQueryRequest<T> : IDeleteByQueryRequest<T>
 		where T : class
 	{
 		public DeleteByQueryRequest() : this(typeof(T), typeof(T)){ }
 
+		/// <inheritdoc />
 		public QueryContainer Query { get; set; }
+
+		/// <inheritdoc />
+		public ISlicedScroll Slice { get; set; }
 	}
 
+	/// <inheritdoc cref="IDeleteByQueryRequest"/>
 	public partial class DeleteByQueryDescriptor<T> : IDeleteByQueryRequest<T>
 		where T : class
 	{
 		QueryContainer IDeleteByQueryRequest.Query { get; set; }
+		ISlicedScroll IDeleteByQueryRequest.Slice { get; set; }
 
+		/// <summary>
+		/// A match_all query to select all documents. Convenient shorthand for specifying
+		/// a match_all query using <see cref="Query"/>
+		/// </summary>
 		public DeleteByQueryDescriptor<T> MatchAll() => Assign(a => a.Query = new QueryContainerDescriptor<T>().MatchAll());
 
+		/// <summary>
+		/// The query to use to select documents for deletion
+		/// </summary>
 		public DeleteByQueryDescriptor<T> Query(Func<QueryContainerDescriptor<T>, QueryContainer> querySelector) =>
 			Assign(a => a.Query = querySelector?.Invoke(new QueryContainerDescriptor<T>()));
+
+		/// <summary>
+		/// Parallelize the deleting process. This parallelization can improve efficiency and
+		/// provide a convenient way to break the request down into smaller parts.
+		/// </summary>
+		public DeleteByQueryDescriptor<T> Slice(Func<SlicedScrollDescriptor<T>, ISlicedScroll> selector) =>
+			Assign(a => a.Slice = selector?.Invoke(new SlicedScrollDescriptor<T>()));
 	}
 }

src/Nest/Document/Multiple/DeleteByQuery/DeleteByQueryResponse.cs

@@ -17,6 +17,9 @@ public interface IDeleteByQueryResponse : IResponse
 		[JsonProperty("timed_out")]
 		bool TimedOut { get; }
 
+		[JsonProperty("slice_id")]
+		int? SliceId { get; }
+
 		[JsonProperty("deleted")]
 		long Deleted { get; }
 
@@ -58,6 +61,8 @@ public class DeleteByQueryResponse : ResponseBase, IDeleteByQueryResponse
 
 		public bool TimedOut { get; internal set; }
 
+		public int? SliceId { get; internal set; }
+
 		public long Deleted { get; internal set; }
 
 		public long Batches { get; internal set; }

src/Tests/Document/Multiple/DeleteByQuery/DeleteByQueryApiTests.cs

@@ -7,6 +7,7 @@
 using Tests.Framework;
 using Tests.Framework.Integration;
 using Tests.Framework.ManagedElasticsearch.Clusters;
+using Tests.Framework.ManagedElasticsearch.NodeSeeders;
 using Tests.Framework.MockData;
 using Xunit;
 using static Nest.Infer;
@@ -21,10 +22,23 @@ protected override void IntegrationSetup(IElasticClient client, CallUniqueValues
 		{
 			foreach (var index in values.Values)
 			{
+				this.Client.CreateIndex(index, c => c
+					.Settings(s => s
+						.NumberOfShards(2)
+						.NumberOfReplicas(0)
+						.Analysis(DefaultSeeder.ProjectAnalysisSettings)
+					)
+					.Mappings(m => m
+						.Map<Project>(p => p
+							.AutoMap()
+							.Properties(DefaultSeeder.ProjectProperties)
+						)
+					)
+				);
+
 				this.Client.IndexMany(Project.Projects, index);
 				var cloneIndex = index + "-clone";
 				this.Client.CreateIndex(cloneIndex);
-
 				this.Client.Refresh(Index(index).And(cloneIndex));
 			}
 		}
@@ -200,4 +214,75 @@ protected override void ExpectResponse(IDeleteByQueryResponse response)
 			failure.Cause.Type.Should().NotBeNullOrWhiteSpace();
 		}
 	}
+
+	public class DeleteByQueryWithSlicesApiTests : DeleteByQueryApiTests
+	{
+		private static List<string> FirstTenProjectNames => Project.Projects.Take(10).Select(p => p.Name).ToList();
+
+		public DeleteByQueryWithSlicesApiTests(IntrusiveOperationCluster cluster, EndpointUsage usage) : base(cluster, usage) { }
+
+		protected override bool ExpectIsValid => true;
+		protected override int ExpectStatusCode => 200;
+
+		protected override string UrlPath => $"/{CallIsolatedValue}/project/_delete_by_query";
+
+		protected override object ExpectJson =>
+			new
+			{
+				slice = new { id = 0, max = 2 },
+				query = new { terms = new { name = new { terms = FirstTenProjectNames } } }
+			};
+
+		protected override DeleteByQueryDescriptor<Project> NewDescriptor() => new DeleteByQueryDescriptor<Project>(this.CallIsolatedValue);
+
+		protected override Func<DeleteByQueryDescriptor<Project>, IDeleteByQueryRequest> Fluent => d => d
+			.Index(this.CallIsolatedValue)
+			.Slice(s => s
+				.Id(0)
+				.Max(2)
+			)
+			.Query(q => q
+				.Terms(m => m
+					.Field(p => p.Name)
+					.Terms(FirstTenProjectNames)
+				)
+			)
+			;
+
+		protected override DeleteByQueryRequest Initializer => new DeleteByQueryRequest(this.CallIsolatedValue, Type<Project>())
+		{
+			Slice = new SlicedScroll
+			{
+				Id = 0,
+				Max = 2
+			},
+			Query = new TermsQuery
+			{
+				Field = Field<Project>(p => p.Name),
+				Terms = FirstTenProjectNames
+			},
+		};
+
+		protected override void ExpectResponse(IDeleteByQueryResponse response)
+		{
+			response.ShouldBeValid();
+			response.SliceId.Should().Be(0);
+
+			// Since we only executed one slice of the two, some of the documents that
+			// match the query will still exist.
+			Client.Refresh(CallIsolatedValue);
+
+			var countResponse = Client.Count<Project>(c => c
+				.Index(CallIsolatedValue)
+				.Query(q => q
+					.Terms(m => m
+						.Field(p => p.Name)
+						.Terms(FirstTenProjectNames)
+					)
+				)
+			);
+
+			countResponse.Count.Should().BeGreaterThan(0);
+		}
+	}
 }