support for _source, _source.include, _source.exclude

Author: Mpdreamz

src/Nest/DSL/Search/SourceDescriptor.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Text;
+using Nest.Resolvers;
+using Newtonsoft.Json;
+
+namespace Nest.DSL.Search
+{
+	public class SourceDescriptor<T> where T : class 
+ 	{
+		[JsonProperty("include")]
+		internal IEnumerable<PropertyPathMarker> _Include { get; set; } 
+
+		[JsonProperty("exclude")]
+		internal IEnumerable<PropertyPathMarker> _Exclude { get; set; } 
+
+		public SourceDescriptor<T> Include(params string[] fields)
+		{
+			this._Include = fields.Select(f => (PropertyPathMarker) f).ToList();
+			return this;
+		} 
+		public SourceDescriptor<T> Include(params Expression<Func<T, object>>[] fields)
+		{
+			this._Include = fields.Select(f => (PropertyPathMarker) f).ToList();
+			return this;
+		} 
+		public SourceDescriptor<T> Include(Func<FluentFieldList<T>, FluentFieldList<T>>  fields)
+		{
+			this._Include = fields(new FluentFieldList<T>()).ToList();
+			return this;
+		}
+		public SourceDescriptor<T> Exclude(params string[] fields)
+		{
+			this._Exclude = fields.Select(f => (PropertyPathMarker) f).ToList();
+			return this;
+		} 
+		public SourceDescriptor<T> Exclude(params Expression<Func<T, object>>[] fields)
+		{
+			this._Exclude = fields.Select(f => (PropertyPathMarker) f).ToList();
+			return this;
+		} 
+		public SourceDescriptor<T> Exclude(Func<FluentFieldList<T>, FluentFieldList<T>>  fields)
+		{
+			this._Exclude = fields(new FluentFieldList<T>()).ToList();
+			return this;
+		}
+	}
+}

src/Nest/DSL/SearchDescriptor.cs

@@ -3,6 +3,7 @@
 using System.Linq;
 using System.Security.Cryptography;
 using System.Text;
+using Nest.DSL.Search;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
 using Nest.Resolvers.Converters;
@@ -280,8 +281,20 @@ internal RawOrFilterDescriptor<T> _FilterOrRaw
 		[JsonConverter(typeof(DictionaryKeysAreNotPropertyNamesJsonConverter))]
 		internal FluentDictionary<string, ScriptFilterDescriptor> _ScriptFields { get; set; }
 
+		[JsonProperty(PropertyName = "_source")]
+		internal object _Source { get; set; }
 
+		public SearchDescriptor<T> Source(bool include = true)
+		{
+			this._Source = include;
+			return this;
+		}
 
+		public SearchDescriptor<T> Source(Func<SourceDescriptor<T>, SourceDescriptor<T>> sourceSelector)
+		{
+			this._Source = sourceSelector(new SourceDescriptor<T>());
+			return this;
+		}
 		/// <summary>
 		/// The number of hits to return. Defaults to 10. When using scroll search type 
 		/// size is actually multiplied by the number of shards!

src/Nest/Domain/Responses/QueryResponse.cs

@@ -80,17 +80,14 @@ public double MaxScore
 			}
 		}
 
+		private IList<T> _documents; 
 		public IEnumerable<T> Documents
 		{
 			get
 			{
-				if (this.HitsMetaData != null)
-				{
-					foreach (var hit in this.HitsMetaData.Hits)
-					{
-						yield return hit.Source;
-					}
-				}
+				if (this.HitsMetaData != null && this._documents == null)
+					this._documents = this.HitsMetaData.Hits.Select(h => h.Source).ToList();
+				return this._documents;
 			}
 		}
 

src/Tests/Nest.Tests.Integration/Search/SubClassSupport/SubClassSupportTests.cs

@@ -15,6 +15,7 @@ public class SubClassSupportTests : IntegrationTests
 		public abstract class MyBaseClass
 		{
 			public string Title { get; set; }
+			public string Description { get; set; }
 		}
 		public class ClassA : MyBaseClass
 		{
@@ -196,6 +197,7 @@ public void MultipleTypesUsingBaseClassMultiSearchSourceInclude()
 					else
 						o = new ClassB() { ClassBProperty = Guid.NewGuid().ToString() };
 					o.Title = Guid.NewGuid().ToString();
+					o.Description = Guid.NewGuid().ToString();
 					return o;
 				});
 
@@ -207,31 +209,38 @@ public void MultipleTypesUsingBaseClassMultiSearchSourceInclude()
 					.Types(typeof(ClassA), typeof(ClassB))
 					.From(0)
 					.Size(100)
-					//.SourceExclude()
-					.Fields(p=>p.Title)
+					.Source(source=>source
+						.Include(i=>i.Add(p=>p.Title).Add("classBProperty"))
+					)
 					.MatchAll()
 				)
 				.Search<MyBaseClass>("using_selector", s => s.AllIndices()
 					.Types("classa", "classb")
 					.ConcreteTypeSelector((o, h) => o.classBProperty != null ? typeof(ClassB) : typeof(ClassA))
 					.From(0)
 					.Size(100)
-					.Fields(f=>f.Add(p=>p.Title).Add("classBProperty"))
+					.Source(source=>source
+						.Include(i=>i.Add(p=>p.Description).Add("classBProperty"))
+					)
 					.MatchAll()
 				)
 			);
 			Assert.True(queryResults.IsValid);
 			var firstResult = queryResults.GetResponse<MyBaseClass>("using_types");
 
 			Assert.True(firstResult.Documents.Any());
-			firstResult.Hits.OfType<Hit<ClassA>>().Any().Should().BeTrue();
-			firstResult.Hits.OfType<Hit<ClassB>>().Any().Should().BeTrue();
+			firstResult.Documents.All(d => !d.Title.IsNullOrEmpty());
+			firstResult.Documents.All(d => d.Description.IsNullOrEmpty());
+			firstResult.Documents.OfType<ClassA>().Any().Should().BeTrue();
+			firstResult.Documents.OfType<ClassB>().Any().Should().BeTrue();
 
 			var secondResult = queryResults.GetResponse<MyBaseClass>("using_selector");
 
 			Assert.True(secondResult.Documents.Any());
-			secondResult.Hits.OfType<Hit<ClassA>>().Any().Should().BeTrue();
-			secondResult.Hits.OfType<Hit<ClassB>>().Any().Should().BeTrue();
+			secondResult.Documents.All(d => d.Title.IsNullOrEmpty());
+			secondResult.Documents.All(d => !d.Description.IsNullOrEmpty());
+			secondResult.Documents.OfType<ClassA>().Any().Should().BeTrue();
+			secondResult.Documents.OfType<ClassB>().Any().Should().BeTrue();
 		}
 	}
 }