Represents a Full Text Search (FTS) query against an index for a given IFtsQuery implementation using ISearchParams.
 /// <summary>
 /// Executes a <see cref="IFtsQuery" /> request including any <see cref="ISearchParams" /> parameters.
 /// </summary>
 /// <param name="searchQuery"></param>
 /// <returns></returns>
 public ISearchQueryResult Query(SearchQuery searchQuery)
 {
     using (new SynchronizationContextExclusion())
     {
         return QueryAsync(searchQuery).Result;
     }
 }
        /// <summary>
        /// Executes a <see cref="IFtsQuery" /> request including any <see cref="ISearchParams" /> parameters asynchronously.
        /// </summary>
        /// <returns>A <see cref="ISearchQueryResult"/> wrapped in a <see cref="Task"/> for awaiting on.</returns>
        public async Task<ISearchQueryResult> QueryAsync(SearchQuery searchQuery)
        {
            var searchResult = new SearchQueryResult();
            var baseUri = ConfigContextBase.GetSearchUri();
            var requestUri = new Uri(baseUri, searchQuery.RelativeUri());
            var searchBody = searchQuery.Export().ToString();

            try
            {
                using (var httpClient = CreateHttpClient())
                using (var content = new StringContent(searchBody, Encoding.UTF8, "application/json"))
                using (var response = await httpClient.PostAsync(requestUri, content).ContinueOnAnyContext())
                using (var stream = await response.Content.ReadAsStreamAsync())
                {
                    if (response.IsSuccessStatusCode)
                    {
                        searchResult = DataMapper.Map<SearchQueryResult>(stream);
                    }
                    else
                    {
                        // ReSharper disable once UseStringInterpolation
                        var message = string.Format("{0}: {1}", (int)response.StatusCode, response.ReasonPhrase);
                        ProcessError(new HttpRequestException(message), searchResult);

                        using (var reader = new StreamReader(stream))
                        {
                            searchResult.Errors.Add(reader.ReadToEnd());
                        }
                        if (response.StatusCode == HttpStatusCode.NotFound)
                        {
                            baseUri.IncrementFailed();
                        }
                    }
                }
                baseUri.ClearFailed();
            }
            catch (HttpRequestException e)
            {
                Log.LogInformation("Search failed {0}: {1}{2}",  baseUri, Environment.NewLine, searchBody);
                baseUri.IncrementFailed();
                ProcessError(e, searchResult);
                Log.LogError(e.Message, e);
            }
            catch (AggregateException ae)
            {
                ae.Flatten().Handle(e =>
                {
                    Log.LogInformation("Search failed {0}: {1}{2}", baseUri, Environment.NewLine, searchBody);
                    ProcessError(e, searchResult);
                    return true;
                });
            }
            catch (Exception e)
            {
                Log.LogInformation("Search failed {0}: {1}{2}", baseUri, Environment.NewLine, searchBody);
                Log.LogInformation(e.Message);
                ProcessError(e, searchResult);
            }
            return searchResult;
        }
 public void Test_Fields_WhenEmpty_ThrowsException()
 {
     SearchQuery fc = new SearchQuery();
     fc.Index = "beer-ft";
     fc.Highlighting(HighLightStyle.Html);
     Assert.Throws<ArgumentNullException>(() => fc.Fields());
 }
 public void Test_SupportsFields()
 {
     //will not throw ArgumentNullException
     SearchQuery fc = new SearchQuery();
     fc.Index = "beer-ft";
     fc.Highlighting(HighLightStyle.Html);
     fc.Fields("name", "style");
 }
        public void ToJson_WithFacets()
        {
            var searchParams = new SearchQuery().Facets(
                new TermFacet("termfacet", "thefield", 10),
                new DateRangeFacet("daterangefacet", "thefield", 10).AddRange(DateTime.Now, DateTime.Now.AddDays(1)),
                new NumericRangeFacet("numericrangefacet", "thefield", 2).AddRange(2.2f, 3.5f));

            Console.WriteLine(searchParams.ToJson());
        }
        public void ToJson_JsonStringIsValid()
        {
            var searchParams = new SearchQuery().
                Skip(20).
                Limit(10).Explain(true).
                Timeout(TimeSpan.FromMilliseconds(10000)).
#pragma warning disable 618
                WithConsistency(ScanConsistency.AtPlus);
#pragma warning restore 618

            //var expected = "{\"ctl\":{\"timeout\":10000,\"consistency\":{\"level\":\"at_plus\",\"vectors\":{\"customerIndex\":{\"0\":123,\"1/a0b1c2\":234}}}},\"query\":{\"query\":\"alice smith\",\"boost\": 1},\"size\": 10,\"from\":20,\"highlight\":{\"style\": null,\"fields\":null},\"fields\":[\"*\"],\"facets\":null,\"explain\":true}";
            var expected = "{\"ctl\":{\"timeout\":10000,\"consistency\":{\"level\":\"at_plus\",\"vectors\":{}}},\"size\":10,\"from\":20,\"explain\":true}";
            var actual = searchParams.ToJson().ToString().Replace("\r\n", "").Replace(" ", "");
            Console.WriteLine(actual);
            Console.WriteLine(expected);
            Assert.AreEqual(expected, actual);
        }
        /// <summary>
        /// Executes a <see cref="IFtsQuery" /> request including any <see cref="ISearchParams" /> parameters asynchronously.
        /// </summary>
        /// <returns>A <see cref="ISearchQueryResult"/> wrapped in a <see cref="Task"/> for awaiting on.</returns>
        public async Task <ISearchQueryResult> QueryAsync(SearchQuery searchQuery)
        {
            var searchResult = new SearchQueryResult();
            var baseUri      = ConfigContextBase.GetSearchUri();
            var requestUri   = new Uri(baseUri, searchQuery.RelativeUri());
            var searchBody   = searchQuery.ToJson();

            try
            {
                using (var content = new StringContent(searchBody, Encoding.UTF8, MediaType.Json))
                    using (var response = await HttpClient.PostAsync(requestUri, content).ContinueOnAnyContext())
                        using (var stream = await response.Content.ReadAsStreamAsync().ContinueOnAnyContext())
                        {
                            if (response.IsSuccessStatusCode)
                            {
                                searchResult = DataMapper.Map <SearchQueryResult>(stream);
                            }
                            else
                            {
                                // ReSharper disable once UseStringInterpolation
                                var message = string.Format("{0}: {1}", (int)response.StatusCode, response.ReasonPhrase);
                                ProcessError(new HttpRequestException(message), searchResult);

                                using (var reader = new StreamReader(stream))
                                {
                                    searchResult.Errors.Add(await reader.ReadToEndAsync().ContinueOnAnyContext());
                                }
                                if (response.StatusCode == HttpStatusCode.NotFound)
                                {
                                    baseUri.IncrementFailed();
                                }
                            }
                        }
                baseUri.ClearFailed();
            }
            catch (HttpRequestException e)
            {
                Log.Info("Search failed {0}: {1}{2}", baseUri, Environment.NewLine, User(searchBody));
                baseUri.IncrementFailed();
                ProcessError(e, searchResult);
                Log.Error(e);
            }
            catch (AggregateException ae)
            {
                ae.Flatten().Handle(e =>
                {
                    Log.Info("Search failed {0}: {1}{2}", baseUri, Environment.NewLine, User(searchBody));
                    ProcessError(e, searchResult);
                    return(true);
                });
            }
            catch (Exception e)
            {
                Log.Info("Search failed {0}: {1}{2}", baseUri, Environment.NewLine, User(searchBody));
                Log.Info(e);
                ProcessError(e, searchResult);
            }

            UpdateLastActivity();

            return(searchResult);
        }
示例#8
0
        /// <summary>
        /// Executes a <see cref="IFtsQuery" /> request including any <see cref="ISearchParams" /> parameters asynchronously.
        /// </summary>
        /// <returns>A <see cref="ISearchQueryResult"/> wrapped in a <see cref="Task"/> for awaiting on.</returns>
        public async Task <ISearchQueryResult> QueryAsync(SearchQuery searchQuery, CancellationToken cancellationToken)
        {
            var searchResult = new SearchQueryResult();
            var baseUri      = Context.GetSearchUri();
            var requestUri   = new Uri(baseUri, searchQuery.RelativeUri());

            string searchBody;

            using (ClientConfiguration.Tracer.BuildSpan(searchQuery, CouchbaseOperationNames.RequestEncoding).Start())
            {
                searchBody = searchQuery.ToJson();
            }

            try
            {
                using (var content = new StringContent(searchBody, Encoding.UTF8, MediaType.Json))
                {
                    HttpResponseMessage response;
                    using (ClientConfiguration.Tracer.BuildSpan(searchQuery, CouchbaseOperationNames.DispatchToServer).Start())
                    {
                        response = await HttpClient.PostAsync(requestUri, content, cancellationToken).ContinueOnAnyContext();
                    }

                    using (ClientConfiguration.Tracer.BuildSpan(searchQuery, CouchbaseOperationNames.ResponseDecoding).Start())
                        using (var stream = await response.Content.ReadAsStreamAsync().ContinueOnAnyContext())
                        {
                            if (response.IsSuccessStatusCode)
                            {
                                searchResult = DataMapper.Map <SearchQueryResult>(stream);
                            }
                            else
                            {
                                string responseContent;
                                using (var reader = new StreamReader(stream))
                                {
                                    responseContent = await reader.ReadToEndAsync().ContinueOnAnyContext();
                                }

                                if (response.Content.Headers.TryGetValues("Content-Type", out var values) &&
                                    values.Any(value => value.Contains(MediaType.Json)))
                                {
                                    // server 5.5+ responds with JSON content
                                    var result = JsonConvert.DeserializeObject <FailedSearchQueryResult>(responseContent);
                                    ProcessError(new HttpRequestException(result.Message), searchResult);
                                    searchResult.Errors.Add(result.Message);
                                }
                                else
                                {
                                    // use response content as raw string
                                    // ReSharper disable once UseStringInterpolation
                                    var message = string.Format("{0}: {1}", (int)response.StatusCode, response.ReasonPhrase);
                                    ProcessError(new HttpRequestException(message), searchResult);
                                    searchResult.Errors.Add(responseContent);
                                }

                                if (response.StatusCode == HttpStatusCode.NotFound)
                                {
                                    baseUri.IncrementFailed();
                                }
                            }
                        }
                }
                baseUri.ClearFailed();
            }
            catch (OperationCanceledException e)
            {
                var operationContext = OperationContext.CreateSearchContext(Context.BucketName, baseUri?.Authority);
                if (searchQuery is SearchQuery query)
                {
                    operationContext.TimeoutMicroseconds = query.TimeoutValue;
                }

                Log.Info(operationContext.ToString());
                ProcessError(e, searchResult);
            }
            catch (HttpRequestException e)
            {
                Log.Info("Search failed {0}: {1}{2}", baseUri, Environment.NewLine, User(searchBody));
                baseUri.IncrementFailed();
                ProcessError(e, searchResult);
                Log.Error(e);
            }
            catch (AggregateException ae)
            {
                ae.Flatten().Handle(e =>
                {
                    Log.Info("Search failed {0}: {1}{2}", baseUri, Environment.NewLine, User(searchBody));
                    ProcessError(e, searchResult);
                    return(true);
                });
            }
            catch (Exception e)
            {
                Log.Info("Search failed {0}: {1}{2}", baseUri, Environment.NewLine, User(searchBody));
                Log.Info(e);
                ProcessError(e, searchResult);
            }

            UpdateLastActivity();

            return(searchResult);
        }
示例#9
0
 /// <summary>
 /// Executes a <see cref="IFtsQuery" /> request including any <see cref="ISearchParams" /> parameters asynchronously.
 /// </summary>
 /// <returns>A <see cref="ISearchQueryResult"/> wrapped in a <see cref="Task"/> for awaiting on.</returns>
 public Task <ISearchQueryResult> QueryAsync(SearchQuery searchQuery)
 {
     return(QueryAsync(searchQuery, CancellationToken.None));
 }