public object Materialize(ElasticResponse response) { var enumerator = response.hits.hits.GetEnumerator(); if (!enumerator.MoveNext()) { if (defaultIfNone) { return(elementType.IsValueType ? Activator.CreateInstance(elementType) : null); } else { throw new InvalidOperationException("Sequence contains no elements"); } } var current = enumerator.Current; if (throwIfMoreThanOne && enumerator.MoveNext()) { throw new InvalidOperationException("Sequence contains more than one element"); } return(itemCreator(current)); }
private async Task <object> ExecuteAsync(ElasticTranslateResult translation, CancellationToken cancellationToken = default(CancellationToken)) { Log.Debug(null, null, "Executing query against document '{0}'", translation.SearchRequest.IndexType); try { ElasticResponse response; if (translation.SearchRequest.Query == ConstantCriteria.False) { response = new ElasticResponse(); } else { response = await requestProcessor.SearchAsync(translation.SearchRequest, cancellationToken).ConfigureAwait(false); if (response == null) { throw new InvalidOperationException("No HTTP response received."); } } var result = translation.Materializer.Materialize(response); response.hits?.hits?.Clear(); // Clear list aggressively return(result); } catch (AggregateException ex) { ExceptionDispatchInfo.Capture(ex.InnerException).Throw(); return(null); // Never called, as the above code re-throws } }
/// <inheritdoc/> public async Task <object> ExecuteAsync(Expression expression, CancellationToken cancellationToken = default(CancellationToken)) { Argument.EnsureNotNull("expression", expression); var translation = ElasticQueryTranslator.Translate(Mapping, expression); Log.Debug(null, null, "Executing query against document '{0}'", translation.SearchRequest.DocumentType); try { ElasticResponse response; if (translation.SearchRequest.Filter == ConstantCriteria.False) { response = new ElasticResponse(); } else { response = await requestProcessor.SearchAsync(translation.SearchRequest, cancellationToken); if (response == null) { throw new InvalidOperationException("No HTTP response received."); } } return(translation.Materializer.Materialize(response)); } catch (AggregateException ex) { ExceptionDispatchInfo.Capture(ex.InnerException).Throw(); return(null); // Never called, as the above code re-throws } }
public string ElasticResponseConstructor_OnValidInput_CreatesValidResponse() { var defaultResponse = new ElasticResponse(); var serializedResponse = JsonConvert.SerializeObject(defaultResponse); return(serializedResponse); }
public object Materialize(ElasticResponse response) { Argument.EnsureNotNull("response", response); using (var enumerator = response.hits.hits.GetEnumerator()) { if (!enumerator.MoveNext()) { if (defaultIfNone) { return(TypeHelper.CreateDefault(elementType)); } else { throw new InvalidOperationException("Sequence contains no elements"); } } var current = enumerator.Current; if (throwIfMoreThanOne && enumerator.MoveNext()) { throw new InvalidOperationException("Sequence contains more than one element"); } return(projector(current)); } }
private object ExecuteInternal(Expression expression) { var translation = ElasticQueryTranslator.Translate(Mapping, Prefix, expression); var elementType = TypeHelper.GetSequenceElementType(expression.Type); Log.Debug(null, null, "Executing query against type {0}", elementType); try { ElasticResponse response; if (translation.SearchRequest.Filter == ConstantCriteria.False) { response = new ElasticResponse(); } else { response = AsyncHelper.RunSync(() => requestProcessor.SearchAsync(translation.SearchRequest)); if (response == null) { throw new InvalidOperationException("No HTTP response received."); } } return(translation.Materializer.Materialize(response)); } catch (AggregateException ex) { ExceptionDispatchInfo.Capture(ex.InnerException).Throw(); return(null); // Never called, as the above code re-throws } }
public async Task <object> ExecuteAsync(Expression expression, CancellationToken cancellationToken = new CancellationToken()) { var translation = ElasticQueryTranslator.Translate(this.Mapping, expression); try { ElasticResponse response; if (translation.SearchRequest.Filter == ConstantCriteria.False) { response = new ElasticResponse(); } else { response = await this.requestProcessor.SearchAsync(translation.SearchRequest, cancellationToken); if (response == null) { throw new InvalidOperationException("No HTTP response received."); } } return(translation.Materializer.Materialize(response)); } catch (AggregateException ex) { ExceptionDispatchInfo.Capture(ex.InnerException).Throw(); return(null); // Never called, as the above code re-throws } }
public ElasticResult <T[]> GetEntitiesFromElasticResponse <T>(ElasticResponse <T> response) where T : class { // If request bad executed. return(!response.Success ? ElasticResult <T[]> .FailResult(response.Message) : ElasticResult <T[]> .SuccessResult( response.Response.Hits.Select(h => h.Source).Where(s => s != null).ToArray())); }
/// <summary> /// Determine whether at a given query response contains any hits. /// </summary> /// <param name="response">The <see cref="ElasticResponse"/> to check for emptiness.</param> /// <returns>true if the source sequence contains any elements; otherwise, false.</returns> public object Materialize(ElasticResponse response) { if (response.hits.total.value < 0) { throw new ArgumentOutOfRangeException(nameof(response), "Contains a negative number of hits."); } return(response.hits.total.value > 0); }
/// <summary> /// Determine whether at a given query response contains any Hits. /// </summary> /// <param name="response">The <see cref="ElasticResponse"/> to check for emptiness.</param> /// <returns>true if the source sequence contains any elements; otherwise, false.</returns> public object Materialize(ElasticResponse response) { if (response.Hits.Total < 0) { throw new ArgumentOutOfRangeException("response", "Contains a negative number of Hits."); } return(response.Hits.Total > 0); }
/// <summary> /// Materialize the result count for a given response. /// </summary> /// <param name="response">The <see cref="ElasticResponse"/> to obtain the count value from.</param> /// <returns>The result count expressed as either an int or long depending on the size of the count.</returns> public object Materialize(ElasticResponse response) { if (response.hits.total < 0) { throw new ArgumentOutOfRangeException(nameof(response), "Contains a negative number of hits."); } return(Convert.ChangeType(response.hits.total, returnType)); }
/// <summary> /// Materialize the facets from an ElasticResponse into a List with a single CLR object as determined /// by the projector. /// </summary> /// <param name="response">ElasticResponse to obtain the facets from.</param> /// <returns>List containing a single CLR object with these facets projected onto them.</returns> public override object Materialize(ElasticResponse response) { Argument.EnsureNotNull("response", response); var element = MaterializeSingle(response); var listType = typeof(List <>).MakeGenericType(ElementType); return(element == null ? Activator.CreateInstance(listType) : manyMethodInfo.MakeGenericMethod(ElementType).Invoke(null, new[] { element })); }
public void CountMaterializerThrowsForNegativeCount() { var response = new ElasticResponse { hits = new Hits { hits = new List <Hit>(), total = -1 } }; var materializer = new CountElasticMaterializer(); Assert.Throws <ArgumentOutOfRangeException>(() => materializer.Materialize(response)); }
public void ThrowsWhenNegativeHits() { const int total = -1; var response = new ElasticResponse { hits = new Hits { hits = new List <Hit>(), total = total } }; var materializer = new AnyElasticMaterializer(); Assert.Throws <ArgumentOutOfRangeException>(() => materializer.Materialize(response)); }
public void ThenWillReturnEmptyListIfHitsIsNull() { //Arrange var response = new ElasticResponse <string>(); //Act var responseItems = response.Items; //Assert responseItems.Should().NotBeNull(); responseItems.Should().BeEmpty(); }
public void MaterializeReturnsEmptyListWhenHitsHitsAreEmpty() { var materializer = new ListHitsElasticMaterializer(MaterializerTestHelper.ItemCreator, typeof(SampleClass)); var response = new ElasticResponse { hits = null }; var materialized = materializer.Materialize(response); var materializedList = Assert.IsType <List <SampleClass> >(materialized); Assert.Empty(materializedList); }
public void MaterializeWithNoFacetsReturnsBlankList() { var materializer = new ListTermlessFacetsElasticMaterializer(r => r, typeof(SampleClass), typeof(string)); var response = new ElasticResponse { facets = new JObject() }; var actual = materializer.Materialize(response); var actualList = Assert.IsType <List <SampleClass> >(actual); Assert.Empty(actualList); }
public void ReturnsTrueWhenOneOrMoreHits(int total) { var response = new ElasticResponse { hits = new Hits { hits = new List <Hit>(), total = total } }; var materializer = new AnyElasticMaterializer(); var actual = materializer.Materialize(response); Assert.Equal(true, actual); }
public void CountMaterializerReturnsIntCount() { const int expected = int.MaxValue; var response = new ElasticResponse { hits = new Hits { hits = new List <Hit>(), total = expected } }; var materializer = new CountElasticMaterializer(typeof(int)); var actual = materializer.Materialize(response); Assert.Equal(expected, actual); }
internal static IEnumerable <string> GetResultSummary(ElasticResponse results) { if (results == null) { yield return("nothing"); } else { if (results.hits?.hits != null && results.hits.hits.Count > 0) { yield return(results.hits.hits.Count + " hits"); } } }
public void ReturnsFalseWhenNoHits() { const int total = 0; var response = new ElasticResponse { hits = new Hits { hits = new List <Hit>(), total = total } }; var materializer = new AnyElasticMaterializer(); var actual = materializer.Materialize(response); Assert.Equal(false, actual); }
/// <summary> /// Materialize the result count for a given response. /// </summary> /// <param name="response">The <see cref="ElasticResponse"/> to obtain the count value from.</param> /// <returns>The ewaulr count expressed as either an int or long depending on the size of the count.</returns> public object Materialize(ElasticResponse response) { if (response.hits.total < 0) { throw new ArgumentOutOfRangeException("response", "Contains a negative number of hits."); } if (response.hits.total <= int.MaxValue) { return((int)response.hits.total); } return(response.hits.total); }
public void CountMaterializerReturnsZeroCount() { const int expected = 0; var response = new ElasticResponse { hits = new Hits { hits = new List <Hit>(), total = expected } }; var materializer = new CountElasticMaterializer(); var actual = materializer.Materialize(response); Assert.Equal(expected, actual); }
public void CountMaterializerReturnsLongCount() { const long expected = ((long)int.MaxValue) + 1; var response = new ElasticResponse { hits = new Hits { hits = new List <Hit>(), total = expected } }; var materializer = new CountElasticMaterializer(); var actual = materializer.Materialize(response); Assert.Equal(expected, actual); }
public object Materialize(ElasticResponse response) { Argument.EnsureNotNull("response", response); var hits = response.hits; if (hits == null || hits.hits == null || !hits.hits.Any()) { return(Activator.CreateInstance(typeof(List <>).MakeGenericType(elementType))); } return(manyMethodInfo .MakeGenericMethod(elementType) .Invoke(null, new object[] { hits.hits, projector })); }
/// <summary> /// Materialize the facets from an ElasticResponse into a List of CLR objects as determined /// by the projector. /// </summary> /// <param name="response">ElasticResponse to obtain the facets from.</param> /// <returns>List of CLR objects with these facets projected onto them.</returns> public object Materialize(ElasticResponse response) { Argument.EnsureNotNull("response", response); var facets = response.facets; if (facets == null || facets.Count == 0) { return(Activator.CreateInstance(typeof(List <>).MakeGenericType(elementType))); } return(manyMethodInfo .MakeGenericMethod(elementType) .Invoke(this, new object[] { response.facets })); }
public void SimpleSelectProducesValidMaterializer() { var translation = ElasticQueryTranslator.Translate(Mapping, Robots.Expression); var response = new ElasticResponse { hits = new Hits { hits = new List <Hit>() } }; Assert.NotNull(translation.Materializer); var materialized = translation.Materializer.Materialize(response); Assert.IsAssignableFrom <IEnumerable <Robot> >(materialized); Assert.Empty((IEnumerable <Robot>)materialized); }
/// <inheritdoc/> public async Task <object> ExecuteAsync(Expression expression, CancellationToken cancellationToken = default(CancellationToken)) { Argument.EnsureNotNull(nameof(expression), expression); var translation = ElasticQueryTranslator.Translate(Mapping, expression); Log.Debug(null, null, "Executing query against document '{0}'", translation.SearchRequest.DocumentType); try { ElasticResponse response; if (translation.SearchRequest.Filter == ConstantCriteria.False) { response = new ElasticResponse(); } else { response = await requestProcessor.SearchAsync(translation.SearchRequest, cancellationToken); if (response == null) { throw new InvalidOperationException("No HTTP response received."); } } var result = translation.Materializer.Materialize(response); if (response.hits != null) { var hits = response.hits.hits; if (hits != null && hits.Capacity > 4096) { // If the response has a large number of hits then the List<T> instance might end up allocating an array on the large object heap. // This means that the elements in that array can survive multiple rounds of garbage collection, even if they are not actually // reachable anymore. // Clearing out the collection after we materialized the result means the elements can be freed up. hits.Clear(); } } return(result); } catch (AggregateException ex) { ExceptionDispatchInfo.Capture(ex.InnerException).Throw(); return(null); // Never called, as the above code re-throws } }
/// <summary> /// Add to response fields that needs to read highlighted info. /// </summary> /// <param name="response">ElasticResponse to obtain the existence of a result.</param> /// <returns>Return result of next materializer</returns> public override object Materialize(ElasticResponse response) { foreach (var hit in response.hits.hits) { if (hit.highlight == null) { continue; } foreach (var prop in hit.highlight.Properties()) { hit._source.Add($"{prop.Name}_highlight", prop.Value); } } return(base.Materialize(response)); }
/// <summary> /// Add to response fields that needs to read highlighted info. /// </summary> /// <param name="response">ElasticResponse to obtain the existence of a result.</param> /// <returns>Return result of next materializer</returns> public override object Materialize(ElasticResponse response) { foreach (var hit in response.Hits.Hits) { if (hit.Highlight == null) { continue; } foreach (var prop in hit.Highlight.Properties()) { hit.Source.Add(string.Format("{0}_highlight", prop.Name), prop.Value); } } return(base.Materialize(response)); }