Example #1
0
        private async ValueTask <RemoteSchemaDefinition?> FetchSchemaDefinitionAsync(
            CancellationToken cancellationToken)
        {
            using var writer = new ArrayWriter();

            IQueryRequest request =
                QueryRequestBuilder.New()
                .SetQuery(
                    $@"query GetSchemaDefinition($c: String!) {{
                            {SchemaDefinitionFieldNames.SchemaDefinitionField}(configuration: $c) {{
                                name
                                document
                                extensionDocuments
                            }}
                        }}")
                .SetVariableValue("c", new StringValueNode(_configuration.Value))
                .Create();

            HttpRequestMessage requestMessage = await HttpRequestClient
                                                .CreateRequestMessageAsync(writer, request, cancellationToken)
                                                .ConfigureAwait(false);

            HttpResponseMessage responseMessage = await _httpClient
                                                  .SendAsync(requestMessage, cancellationToken)
                                                  .ConfigureAwait(false);

            IQueryResult result = await HttpRequestClient
                                  .ParseResponseMessageAsync(responseMessage, cancellationToken)
                                  .ConfigureAwait(false);

            if (result.Errors is { Count : > 1 })
Example #2
0
 /// <summary>
 /// Prepare an ad-hoc N1QL statement for later execution against a Couchbase Server.
 /// </summary>
 /// <param name="toPrepare">The <see cref="IQueryRequest" /> containing a N1QL statement to be prepared.</param>
 /// <returns>
 /// A <see cref="IQueryResult{T}" /> containing  the <see cref="QueryPlan" /> representing the reusable
 /// and cachable execution plan for the statement.
 /// </returns>
 /// <remarks>
 /// Most parameters in the IQueryRequest will be ignored, appart from the Statement and the BaseUri.
 /// </remarks>
 public IQueryResult <QueryPlan> Prepare(IQueryRequest toPrepare)
 {
     using (new SynchronizationContextExclusion())
     {
         return(PrepareAsync(toPrepare, CancellationToken.None).Result);
     }
 }
Example #3
0
 public BackgroundQuery(IRowSourceWrapper rowSource, TaskScheduler backgroundTaskScheduler, IQueryRequest queryRequest)
 {
     RowSource = rowSource;
     BackgroundTaskScheduler = backgroundTaskScheduler;
     QueryRequest = queryRequest;
     _rootCancellationToken = QueryRequest.CancellationToken;
 }
        /// <summary>
        /// Sends a N1QL query to the server to be executed using the <see cref="IQueryRequest" /> object.
        /// </summary>
        /// <typeparam name="T">The Type T of the body of each result row.</typeparam>
        /// <param name="queryRequest">The <see cref="IQueryRequest" /> object to send to the server.</param>
        /// <returns>
        /// An <see cref="IQueryResult{T}" /> object that is the result of the query.
        /// </returns>
        /// <exception cref="ServiceNotSupportedException">The cluster does not support Query services.</exception>
        public override IQueryResult <T> SendWithRetry <T>(IQueryRequest queryRequest)
        {
            IQueryResult <T> queryResult;

            try
            {
                EnsureServiceAvailable(ConfigInfo.IsQueryCapable, "Query");

                queryRequest.Lifespan = new Lifespan
                {
                    CreationTime = DateTime.UtcNow,
                    Duration     = ConfigInfo.ClientConfig.QueryRequestTimeout
                };

                queryResult = RetryRequest(
                    ConfigInfo.GetQueryNode,
                    (server, req) => server.Send <T>(req),
                    (req, res) => !(res.Success || req.TimedOut()) && res.ShouldRetry(),
                    queryRequest
                    );
            }
            catch (Exception e)
            {
                Log.Info(e);
                const string message = "The query request failed, check Error and Exception fields for details.";
                queryResult = new QueryResult <T>
                {
                    Message   = message,
                    Status    = QueryStatus.Fatal,
                    Success   = false,
                    Exception = e
                };
            }
            return(queryResult);
        }
Example #5
0
        public string ExtractQuery(IQueryRequest request)
        {
            var otherDataSets = new List<string>();
            var query = SearchDataSet(
                request.Source
                , request.ReportPath
                , request.ReportName
                , request.DataSetName
                , ref otherDataSets);
            if (string.IsNullOrEmpty(query))
            {
                var reference = SearchSharedDataSet(
                    request.Source
                    , request.ReportPath
                    , request.ReportName
                    , request.DataSetName
                    , ref otherDataSets);
                if (!string.IsNullOrEmpty(reference))
                    query = ReadQueryFromSharedDataSet(request.Source, reference);
            }

            if (!string.IsNullOrEmpty(query))
                return query;

            if (otherDataSets.Count() == 0)
                throw new ArgumentException(string.Format("No report found on path '{0}' with name '{1}'", request.ReportPath, request.ReportName));
            else if (otherDataSets.Count() == 1)
                throw new ArgumentException(string.Format("The requested dataset ('{2}') wasn't found for the report on path '{0}' with name '{1}'. The dataset for this report is {3}", request.ReportPath, request.ReportName, request.DataSetName, otherDataSets[0]));
            else
                throw new ArgumentException(string.Format("The requested dataset ('{2}') wasn't found for the report on path '{0}' with name '{1}'. The datasets for this report are {3}", request.ReportPath, request.ReportName, request.DataSetName, String.Join(", ", otherDataSets.ToArray())));
        }
Example #6
0
        /// <summary>
        /// Executes the <see cref="IQueryRequest"/> using HTTP POST to the Couchbase Server asynchronously.
        /// </summary>
        /// <typeparam name="T">The <see cref="Type"/> of each row returned by the query.</typeparam>
        /// <param name="queryRequest">The query request.</param>
        /// <returns></returns>
        /// <remarks>The format for the querying is JSON</remarks>
        private async Task <IQueryResult <T> > ExecuteQueryAsync <T>(IQueryRequest queryRequest)
        {
            var queryResult = new QueryResult <T>();

            using (var content = new StringContent(queryRequest.GetFormValuesAsJson(), System.Text.Encoding.UTF8, "application/json")) {
                try
                {
                    var request = await HttpClient.PostAsync(queryRequest.GetBaseUri(), content);

                    using (var response = await request.Content.ReadAsStreamAsync())
                    {
                        queryResult         = DataMapper.Map <QueryResult <T> >(response);
                        queryResult.Success = queryResult.Status == QueryStatus.Success;
                    }
                }
                catch (AggregateException ae)
                {
                    ae.Flatten().Handle(e =>
                    {
                        Log.Error(e);
                        ProcessError(e, queryResult);
                        return(true);
                    });
                }
            }

            return(queryResult);
        }
Example #7
0
        /// <summary>
        /// Executes the <see cref="IQueryRequest"/> against the Couchbase server asynchronously.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="queryRequest">The query request.</param>
        /// <param name="cancellationToken">Token which can cancel the query.</param>
        /// <returns></returns>
        public async Task <IQueryResult <T> > QueryAsync <T>(IQueryRequest queryRequest, CancellationToken cancellationToken)
        {
            //shortcut for adhoc requests
            if (queryRequest.IsAdHoc)
            {
                return(await ExecuteQueryAsync <T>(queryRequest, cancellationToken).ContinueOnAnyContext());
            }

            //optimize, return an error result if optimization step cannot complete
            try
            {
                await PrepareStatementIfNotAdHocAsync(queryRequest, cancellationToken).ContinueOnAnyContext();
            }
            catch (Exception e)
            {
                var errorResult = new QueryResult <T>();
                ProcessError(e, errorResult);
                return(errorResult);
            }

            // execute optimized query
            var result = await ExecuteQueryAsync <T>(queryRequest, cancellationToken).ContinueOnAnyContext();

            // if the query failed, check if the query plan should be evicted
            if (!result.Success && result.IsQueryPlanStale())
            {
                var originalStatement = queryRequest.GetOriginalStatement();
                _queryCache.TryRemove(originalStatement, out QueryPlan _);
            }

            return(result);
        }
Example #8
0
        /// <summary>
        /// Prepares the statement if the <see cref="IQueryRequest"/> is not ad-hoc and caches it for reuse.asynchronously.
        /// </summary>
        /// <param name="originalRequest">The original query request.</param>
        /// <param name="cancellationToken">Token which can cancel the query.</param>
        private async Task PrepareStatementIfNotAdHocAsync(IQueryRequest originalRequest, CancellationToken cancellationToken)
        {
            if (originalRequest.IsAdHoc)
            {
                return;
            }

            var originalStatement = originalRequest.GetOriginalStatement();

            if (_queryCache.TryGetValue(originalStatement, out var queryPlan))
            {
                originalRequest.Prepared(queryPlan, originalStatement);
            }
            else
            {
                var result = await PrepareAsync(originalRequest, cancellationToken).ContinueOnAnyContext();

                if (!result.Success)
                {
                    throw new PrepareStatementException("Unable to optimize async statement: " + result.GetErrorsAsString());
                }
                queryPlan = result.FirstOrDefault();
                if (queryPlan != null && _queryCache.TryAdd(originalStatement, queryPlan))
                {
                    originalRequest.Prepared(queryPlan, originalStatement);
                }
            }
        }
Example #9
0
        /// <summary>
        /// Sends a N1QL query to the server to be executed using the <see cref="IQueryRequest"/> object using async/await.
        /// </summary>
        /// <typeparam name="T">The Type T of the body of each result row.</typeparam>
        /// <param name="queryRequest">The <see cref="IQueryRequest"/> object to send to the server.</param>
        /// <returns>An <see cref="Task{IQueryResult}"/> object to be awaited on that is the result of the query.</returns>
        public override async Task <IQueryResult <T> > SendWithRetryAsync <T>(IQueryRequest queryRequest)
        {
            var tcs = new TaskCompletionSource <IQueryResult <T> >();
            IQueryResult <T> queryResult = null;

            try
            {
                var server = ConfigInfo.GetServer();
                queryResult = await server.SendAsync <T>(queryRequest).ConfigureAwait(false);

                tcs.TrySetResult(queryResult);
            }
            catch (Exception e)
            {
                Log.Info(e);
                const string message = "View request failed, check Error and Exception fields for details.";
                queryResult = new QueryResult <T>
                {
                    Message   = message,
                    Status    = QueryStatus.Fatal,
                    Success   = false,
                    Exception = e
                };
                tcs.SetResult(queryResult);
            }
            return(queryResult);
        }
Example #10
0
        public IQueryResult <IQueryPlan> Prepare(IQueryRequest toPrepare)
        {
            var uri = new Uri(GetBaseQueryUri());

            toPrepare.BaseUri(uri);
            return(QueryClient.Prepare(toPrepare));
        }
Example #11
0
        /// <summary>
        /// Executes the <see cref="IQueryRequest"/> against the Couchbase server.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="queryRequest">The query request.</param>
        /// <returns></returns>
        public IQueryResult <T> Query <T>(IQueryRequest queryRequest)
        {
            //shortcut for adhoc requests
            if (queryRequest.IsAdHoc)
            {
                return(ExecuteQuery <T>(queryRequest));
            }

            //optimize, return an error result if optimization step cannot complete
            try
            {
                PrepareStatementIfNotAdHoc(queryRequest);
            }
            catch (Exception e)
            {
                var errorResult = new QueryResult <T>();
                ProcessError(e, errorResult);
                return(errorResult);
            }

            //execute and retry if needed
            var result = ExecuteQuery <T>(queryRequest);

            if (CheckRetry <T>(queryRequest, result))
            {
                return(Retry <T>(queryRequest));
            }
            else
            {
                return(result);
            }
        }
Example #12
0
 /// <summary>
 /// Executes the <see cref="IQueryRequest"/> against the Couchbase server.
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="queryRequest">The query request.</param>
 /// <returns></returns>
 public IQueryResult <T> Query <T>(IQueryRequest queryRequest)
 {
     using (new SynchronizationContextExclusion())
     {
         return(QueryAsync <T>(queryRequest, CancellationToken.None).Result);
     }
 }
        /// <summary>
        /// Executes the <see cref="IQueryRequest"/> against the Couchbase server asynchronously.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="queryRequest">The query request.</param>
        /// <param name="cancellationToken">Token which can cancel the query.</param>
        /// <returns></returns>
        public async Task <IQueryResult <T> > QueryAsync <T>(IQueryRequest queryRequest, CancellationToken cancellationToken)
        {
            //shortcut for adhoc requests
            if (queryRequest.IsAdHoc)
            {
                return(await ExecuteQueryAsync <T>(queryRequest, cancellationToken).ContinueOnAnyContext());
            }

            //optimize, return an error result if optimization step cannot complete
            try
            {
                await PrepareStatementIfNotAdHocAsync(queryRequest, cancellationToken).ContinueOnAnyContext();
            }
            catch (Exception e)
            {
                var errorResult = new QueryResult <T>();
                ProcessError(e, errorResult);
                return(errorResult);
            }

            //execute first attempt
            var result = await ExecuteQueryAsync <T>(queryRequest, cancellationToken).ContinueOnAnyContext();

            //if needed, do a second attempt after having cleared the cache
            if (CheckRetry(queryRequest, result))
            {
                return(await RetryAsync <T>(queryRequest, cancellationToken).ContinueOnAnyContext());
            }
            else
            {
                return(result);
            }
        }
 public Task <IExecutionResult> ExecuteAsync(
     IQueryRequest request,
     CancellationToken cancellationToken = default)
 {
     Request = request;
     return(Task.FromResult <IExecutionResult>(null !));
 }
Example #15
0
        /// <summary>
        /// Sends a request for a N1QL query to the server.
        /// </summary>
        /// <typeparam name="T">The <see cref="Type" /> T of the body for each row (or document) result.</typeparam>
        /// <param name="queryRequest">A <see cref="IQueryRequest" /> object.</param>
        /// <param name="cancellationToken">Token which can cancel the query.</param>
        /// <returns></returns>
        async Task <IQueryResult <T> > IServer.SendAsync <T>(IQueryRequest queryRequest, CancellationToken cancellationToken)
        {
            IQueryResult <T> result;

            if (_isDown)
            {
                result = HandleNodeUnavailable <T>(queryRequest);
            }
            else
            {
                try
                {
                    queryRequest.BaseUri(CachedQueryBaseUri);
                    if (queryRequest.IsStreaming)
                    {
                        result = await _streamingQueryClient.QueryAsync <T>(queryRequest, cancellationToken).ContinueOnAnyContext();
                    }
                    else
                    {
                        result = await QueryClient.QueryAsync <T>(queryRequest, cancellationToken).ContinueOnAnyContext();
                    }
                }
                catch (Exception e)
                {
                    result = new QueryResult <T>
                    {
                        Exception = e,
                        Message   = e.Message,
                        Success   = false
                    };
                }
            }
            return(result);
        }
Example #16
0
        /// <summary>
        /// Prepare an ad-hoc N1QL statement for later execution against a Couchbase Server.
        /// </summary>
        /// <param name="toPrepare">The <see cref="IQueryRequest" /> containing a N1QL statement to be prepared.</param>
        /// <returns>
        /// A <see cref="IQueryResult{T}" /> containing  the <see cref="IQueryPlan" /> representing the reusable
        /// and cachable execution plan for the statement.
        /// </returns>
        /// <remarks>
        /// Most parameters in the IQueryRequest will be ignored, appart from the Statement and the BaseUri.
        /// </remarks>
        public IQueryResult <IQueryPlan> Prepare(IQueryRequest toPrepare)
        {
            string statement = toPrepare.GetStatement();

            if (!statement.ToUpper().StartsWith("PREPARE "))
            {
                statement = string.Concat("PREPARE ", statement);
            }
            QueryRequest query = new QueryRequest(statement);

            query.BaseUri(toPrepare.GetBaseUri());
            IQueryResult <dynamic>    planResult = Query <dynamic>(query);
            IQueryResult <IQueryPlan> result     = new QueryResult <IQueryPlan>()
            {
                Message         = planResult.Message,
                ClientContextId = planResult.ClientContextId,
                Errors          = planResult.Errors,
                Exception       = planResult.Exception,
                Metrics         = planResult.Metrics,
                RequestId       = planResult.RequestId,
                Signature       = planResult.Signature,
                Status          = planResult.Status,
                Rows            = new List <IQueryPlan>(1),
                Success         = planResult.Success
            };

            if (planResult.Success)
            {
                var    rawPlan     = planResult.Rows.First();
                string encodedPlan = EncodeParameter(rawPlan);
                result.Rows.Add(new QueryPlan(encodedPlan));
            }
            return(result);
        }
Example #17
0
        /// <summary>
        /// Sends a request for a N1QL query to the server asynchronously.
        /// </summary>
        /// <typeparam name="T">The <see cref="Type" /> T of the body for each row (or document) result.</typeparam>
        /// <param name="queryRequest">A <see cref="IQueryRequest" /> object.</param>
        /// <returns>
        /// An <see cref="Task{IQueryResult}" /> object representing the asynchronous operation.
        /// </returns>
        IQueryResult <T> IServer.Send <T>(IQueryRequest queryRequest)
        {
            IQueryResult <T> result;

            if (_isDown)
            {
                result = HandleNodeUnavailable <T>(queryRequest);
            }
            else
            {
                try
                {
                    queryRequest.BaseUri(CachedQueryBaseUri);
                    result = QueryClient.Query <T>(queryRequest);
                }
                catch (Exception e)
                {
                    MarkDead();
                    result = new QueryResult <T>
                    {
                        Exception = e,
                        Message   = e.Message,
                        Success   = false,
                    };
                }
            }
            return(result);
        }
        /// <summary>
        /// Sends a N1QL query to the server to be executed using the <see cref="IQueryRequest" /> object.
        /// </summary>
        /// <typeparam name="T">The Type T of the body of each result row.</typeparam>
        /// <param name="queryRequest">The <see cref="IQueryRequest" /> object to send to the server.</param>
        /// <returns>
        /// An <see cref="IQueryResult{T}" /> object that is the result of the query.
        /// </returns>
        public override IQueryResult <T> SendWithRetry <T>(IQueryRequest queryRequest)
        {
            //Is the cluster configured for Data services?
            if (!ConfigInfo.IsQueryCapable)
            {
                throw new ServiceNotSupportedException("The cluster does not support Query services.");
            }

            IQueryResult <T> queryResult = null;

            try
            {
                var server = ConfigInfo.GetQueryNode();
                queryResult = server.Send <T>(queryRequest);
            }
            catch (Exception e)
            {
                Log.Info(e);
                const string message = "View request failed, check Error and Exception fields for details.";
                queryResult = new QueryResult <T>
                {
                    Message   = message,
                    Status    = QueryStatus.Fatal,
                    Success   = false,
                    Exception = e
                };
            }
            return(queryResult);
        }
        public async ValueTask InvokeAsync(IRequestContext context)
        {
            IQueryRequest request    = context.Request;
            bool          addToCache = true;

            if (context.Document is null)
            {
                if (request.QueryId is { } queryId&&
                    _documentCache.TryGetDocument(queryId, out DocumentNode document))
                {
                    context.DocumentId       = queryId;
                    context.Document         = document;
                    context.ValidationResult = DocumentValidatorResult.Ok;
                    context.IsCachedDocument = true;
                    addToCache = false;
                    _diagnosticEvents.RetrievedDocumentFromCache(context);
                }
                else if (request.QueryHash is { } queryHash&&
                         _documentCache.TryGetDocument(queryHash, out document))
                {
                    context.DocumentId       = queryHash;
                    context.Document         = document;
                    context.ValidationResult = DocumentValidatorResult.Ok;
                    context.IsCachedDocument = true;
                    addToCache = false;
                    _diagnosticEvents.RetrievedDocumentFromCache(context);
                }
Example #20
0
 public BackgroundQuery(RowSourceWrapper rowSource, TaskScheduler backgroundTaskScheduler, IQueryRequest queryRequest)
 {
     RowSource = rowSource;
     BackgroundTaskScheduler = backgroundTaskScheduler;
     QueryRequest            = queryRequest;
     _rootCancellationToken  = QueryRequest.CancellationToken;
 }
Example #21
0
        /// <iniheritdoc />
        public Task <IExecutionResult> ExecuteAsync(
            IQueryRequest request,
            CancellationToken cancellationToken = default)
        {
            var bufferRequest = BufferedRequest.Create(request, Schema);

            _semaphore.Wait(cancellationToken);

            try
            {
                _bufferedRequests.Add(bufferRequest);

                if (!_taskRegistered)
                {
                    _batchScheduler.Schedule(() => ExecuteRequestsInternal(cancellationToken));
                    _taskRegistered = true;
                }
            }
            finally
            {
                _semaphore.Release();
            }

            return(bufferRequest.Promise.Task);
        }
Example #22
0
        public async Task Create_BufferedRequest_Rewrite_Variables_To_Literals()
        {
            // arrange
            ISchema schema =
                await new ServiceCollection()
                .AddGraphQL()
                .AddCustomerSchema()
                .BuildSchemaAsync();

            var query = "query abc($id: ID) { customer(id: $id) { name } }";

            IQueryRequest request =
                QueryRequestBuilder.New()
                .SetQuery(query)
                .SetVariableValue("id", 1)
                .Create();

            // act
            var bufferedRequest = BufferedRequest.Create(request, schema);

            // assert
            Assert.NotEqual(request, bufferedRequest.Request);
            Assert.Collection(bufferedRequest.Request.VariableValues !,
                              t => Assert.IsType <StringValueNode>(t.Value));
        }
Example #23
0
        public async Task Create_BufferedRequest_Operation_Correctly_Resolved()
        {
            // arrange
            ISchema schema =
                await new ServiceCollection()
                .AddGraphQL()
                .AddCustomerSchema()
                .BuildSchemaAsync();

            var query = "query abc($id: ID) { customer(id: $id) { name } } " +
                        "query def($id: ID) { customer(id: $id) { name } }";

            IQueryRequest request =
                QueryRequestBuilder.New()
                .SetQuery(query)
                .SetOperation("def")
                .Create();

            // act
            var bufferedRequest = BufferedRequest.Create(request, schema);

            // assert
            Assert.Equal(request, bufferedRequest.Request);
            Assert.Equal(query, bufferedRequest.Document.ToString(false));
            Assert.Equal(
                bufferedRequest.Document.Definitions.OfType <OperationDefinitionNode>().Last(),
                bufferedRequest.Operation);
            Assert.NotNull(bufferedRequest.Promise);
            Assert.Null(bufferedRequest.Aliases);
        }
Example #24
0
        static async Task <IQueryResult <T> > RetryQueryEveryAsync <T>(Func <IQueryRequest, IConfigInfo, Task <IQueryResult <T> > > execute,
                                                                       IQueryRequest query,
                                                                       IConfigInfo configInfo,
                                                                       CancellationToken cancellationToken)
        {
            const int maxAttempts = 10;
            var       attempts    = 0;

            while (true)
            {
                IResult result = await execute(query, configInfo).ContinueOnAnyContext();

                if (result.Success || query.TimedOut() ||
                    !result.ShouldRetry() || attempts >= maxAttempts)
                {
                    return((IQueryResult <T>)result);
                }

                Log.Debug(m => m("trying query again: {0}", attempts));
                var sleepTime = (int)Math.Pow(2, attempts++);
                var task      = Task.Delay(sleepTime, cancellationToken).ContinueOnAnyContext();
                try
                {
                    await task;
                }
                catch (TaskCanceledException)
                {
                    return((IQueryResult <T>)result);
                }
            }
        }
Example #25
0
        /// <summary>
        /// Sends a request for a N1QL query to the server.
        /// </summary>
        /// <typeparam name="T">The <see cref="Type" /> T of the body for each row (or document) result.</typeparam>
        /// <param name="queryRequest">A <see cref="IQueryRequest" /> object.</param>
        /// <returns></returns>
        async Task <IQueryResult <T> > IServer.SendAsync <T>(IQueryRequest queryRequest)
        {
            IQueryResult <T> result;

            if (_isDown)
            {
                result = HandleNodeUnavailable <T>(queryRequest);
            }
            else
            {
                try
                {
                    queryRequest.BaseUri(CachedQueryBaseUri);
                    result = await QueryClient.QueryAsync <T>(queryRequest).ContinueOnAnyContext();
                }
                catch (Exception e)
                {
                    MarkDead();
                    result = new QueryResult <T>
                    {
                        Exception = e,
                        Message   = e.Message,
                        Success   = false
                    };
                }
            }
            return(result);
        }
Example #26
0
        public static BufferedRequest Create(IQueryRequest request, ISchema schema)
        {
            if (request is null)
            {
                throw new ArgumentNullException(nameof(request));
            }

            if (schema == null)
            {
                throw new ArgumentNullException(nameof(schema));
            }

            if (request.Query is null)
            {
                throw new ArgumentException(
                          StitchingResources.BufferedRequest_Create_QueryCannotBeNull,
                          nameof(request));
            }

            DocumentNode document =
                request.Query is QueryDocument doc
                    ? doc.Document
                    : Utf8GraphQLParser.Parse(request.Query.AsSpan());

            OperationDefinitionNode operation =
                ResolveOperation(document, request.OperationName);

            request = NormalizeRequest(request, operation, schema);

            return(new BufferedRequest(request, document, operation));
        }
Example #27
0
        public IQueryRequest Create(IQueryRequest originalRequest, IAdvancedFiltersViewModel advancedFiltersViewModel)
        {
            IQueryRequest result = originalRequest;

            if (originalRequest is SearchQueryRequest sourceSearchQueryRequest)
            {
                var searchQueryRequest = new SearchQueryRequest
                {
                    League = sourceSearchQueryRequest.League,
                    Query  =
                    {
                        Name    = sourceSearchQueryRequest.Query.Name,
                        Term    = sourceSearchQueryRequest.Query.Term,
                        Type    = sourceSearchQueryRequest.Query.Type,
                        Filters =
                        {
                            TypeFilters  =
                            {
                                Category = (OptionFilter)sourceSearchQueryRequest.Query.Filters.TypeFilters.Category?.Clone(),
                                Rarity   = (OptionFilter)sourceSearchQueryRequest.Query.Filters.TypeFilters.Rarity?.Clone()
                            }
                        }
                    }
                };

                SetStatFilters(advancedFiltersViewModel, searchQueryRequest);
                SetAdditionalFilters(advancedFiltersViewModel, searchQueryRequest);

                result = searchQueryRequest;
            }

            return(result);
        }
        /// <summary>
        /// Sends a N1QL query to the server to be executed using the <see cref="IQueryRequest"/> object using async/await.
        /// </summary>
        /// <typeparam name="T">The Type T of the body of each result row.</typeparam>
        /// <param name="queryRequest">The <see cref="IQueryRequest"/> object to send to the server.</param>
        /// <returns>An <see cref="Task{IQueryResult}"/> object to be awaited on that is the result of the query.</returns>
        public override async Task <IQueryResult <T> > SendWithRetryAsync <T>(IQueryRequest queryRequest)
        {
            var tcs = new TaskCompletionSource <IQueryResult <T> >();

            //Is the cluster configured for Data services?
            if (!ConfigInfo.IsQueryCapable)
            {
                tcs.SetException(
                    new ServiceNotSupportedException("The cluster does not support Query services."));
            }

            IQueryResult <T> queryResult = null;

            try
            {
                var server = ConfigInfo.GetQueryNode();
                queryResult = await server.SendAsync <T>(queryRequest).ConfigureAwait(false);

                tcs.TrySetResult(queryResult);
            }
            catch (Exception e)
            {
                Log.Info(e);
                const string message = "View request failed, check Error and Exception fields for details.";
                queryResult = new QueryResult <T>
                {
                    Message   = message,
                    Status    = QueryStatus.Fatal,
                    Success   = false,
                    Exception = e
                };
                tcs.SetResult(queryResult);
            }
            return(queryResult);
        }
Example #29
0
        /// <summary>
        /// Sends a request for a N1QL query to the server asynchronously.
        /// </summary>
        /// <typeparam name="T">The <see cref="Type" /> T of the body for each row (or document) result.</typeparam>
        /// <param name="queryRequest">A <see cref="IQueryRequest" /> object.</param>
        /// <returns>
        /// An <see cref="Task{IQueryResult}" /> object representing the asynchronous operation.
        /// </returns>
        IQueryResult <T> IServer.Send <T>(IQueryRequest queryRequest)
        {
            IQueryResult <T> result;

            if (_isDown)
            {
                result = HandleNodeUnavailable <T>(queryRequest);
            }
            else
            {
                try
                {
                    queryRequest.BaseUri(CachedQueryBaseUri);
                    // ReSharper disable once ConvertIfStatementToConditionalTernaryExpression
                    if (queryRequest.IsStreaming)
                    {
                        result = _streamingQueryClient.Query <T>(queryRequest);
                    }
                    else
                    {
                        result = QueryClient.Query <T>(queryRequest);
                    }
                }
                catch (Exception e)
                {
                    result = new QueryResult <T>
                    {
                        Exception = e,
                        Message   = e.Message,
                        Success   = false,
                    };
                }
            }
            return(result);
        }
Example #30
0
 public virtual ValueTask OnCreateRequestAsync(
     NameString targetSchema,
     IQueryRequest request,
     HttpRequestMessage requestMessage,
     CancellationToken cancellationToken = default)
 {
     return(default);
Example #31
0
        private async Task <IQueryResult <T> > PostAsync <T>(IQueryRequest queryRequest)
        {
            var queryResult = new QueryResult <T>();
            var content     = new FormUrlEncodedContent(queryRequest.GetFormValues());

            try
            {
                var request = await HttpClient.PostAsync(queryRequest.GetBaseUri(), content);

                using (var response = await request.Content.ReadAsStreamAsync())
                {
                    queryResult         = DataMapper.Map <QueryResult <T> >(response);
                    queryResult.Success = queryResult.Status == QueryStatus.Success;
                }
            }
            catch (AggregateException ae)
            {
                ae.Flatten().Handle(e =>
                {
                    Log.Error(e);
                    ProcessError(e, queryResult);
                    return(true);
                });
            }
            return(queryResult);
        }
Example #32
0
        /// <summary>
        /// Prepares the statement if the <see cref="IQueryRequest"/> is not ad-hoc and caches it for reuse.asynchronously.
        /// </summary>
        /// <param name="originalRequest">The original query request.</param>
        async Task PrepareStatementIfNotAdHocAsync(IQueryRequest originalRequest)
        {
            if (originalRequest.IsAdHoc)
            {
                return;
            }

            var       originalStatement = originalRequest.GetOriginalStatement();
            QueryPlan queryPlan;

            if (_queryCache.TryGetValue(originalStatement, out queryPlan))
            {
                originalRequest.Prepared(queryPlan, originalStatement);
            }
            else
            {
                var result = await PrepareAsync(originalRequest);

                if (!result.Success)
                {
                    Log.WarnFormat("Failure to prepare async plan for query {0} (it will be reattempted next time it is issued): {1}",
                                   originalStatement, result.GetErrorsAsString());
                    throw new PrepareStatementException("Unable to optimize async statement: " + result.GetErrorsAsString());
                }
                queryPlan = result.Rows.FirstOrDefault();
                if (queryPlan != null && _queryCache.TryAdd(originalStatement, queryPlan))
                {
                    originalRequest.Prepared(queryPlan, originalStatement);
                }
            }
        }
        private async Task<SelectedSnapshot> taskLoadAsync(IQueryRequest N1QLQueryRequest)
        {
            Task<IQueryResult<SnapshotEntry>> queryTask = _CBBucket.QueryAsync<SnapshotEntry>(N1QLQueryRequest);
            IQueryResult<SnapshotEntry> result = await queryTask;
            if (result.Rows.Count == 0)
                throw new Exception("No Snapshots Found");

            return ToSelectedSnapshot(result.Rows[0]);
        }
Example #34
0
        private Exception BuildDataSetNotFoundException(IQueryRequest request, XmlDocument docXml, string xpath, XmlNamespaceManager nsmgr)
        {
            var nodes = docXml.SelectNodes(xpath, nsmgr);
            var dataSetFound = new List<String>();
            foreach (XmlNode node in nodes)
                dataSetFound.Add(node.Attributes["Name"].Value);

            if (dataSetFound.Count() > 1)
                throw new ArgumentException(string.Format("The requested dataset ('{2}') wasn't found for the report on path '{0}' with name '{1}'. The datasets for this report are {3}", request.ReportPath, request.ReportName, request.DataSetName, String.Join(", ", dataSetFound.ToArray())));
            else
                throw new ArgumentException(string.Format("The requested dataset ('{2}') wasn't found for the report on path '{0}' with name '{1}'. The dataset for this report is named '{3}'", request.ReportPath, request.ReportName, request.DataSetName, dataSetFound[0]));
        }
Example #35
0
        public string ExtractQuery(IQueryRequest request)
        {
            var fullPath = string.Format("{0}{1}", request.ReportPath, request.ReportName);
            if (!File.Exists(fullPath))
                throw new ArgumentException(string.Format("No report found on path '{0}' with name '{1}'", request.ReportPath, request.ReportName));

            var docXml = new XmlDocument();
            docXml.Load(fullPath);
            var xpath = string.Format("//rd:Report/rd:DataSets/rd:DataSet[@Name=\"{0}\"]/rd:Query/rd:CommandText", request.DataSetName);

            var nsmgr = new XmlNamespaceManager(docXml.NameTable);
            nsmgr.AddNamespace("rd", "http://schemas.microsoft.com/sqlserver/reporting/2008/01/reportdefinition");

            var node = docXml.SelectSingleNode(xpath, nsmgr);
            if (node != null)
                return node.InnerText;
            else
                throw BuildDataSetNotFoundException(request, docXml, "//rd:Report/rd:DataSets/rd:DataSet", nsmgr);
        }
        public QueryTimer(IQueryRequest queryRequest, ITimingStore store, bool enableQueryTiming)
        {
            Store = store;
            if (!store.Enabled || !enableQueryTiming) return;

            if (queryRequest == null)
            {
                throw new ArgumentException(QueryMustBeProvided);
            }

            if (string.IsNullOrEmpty(queryRequest.GetOriginalStatement()))
            {
                throw new ArgumentException(QueryStatementMustBeProvided);
            }

            _statement = queryRequest.GetOriginalStatement();
            _enableQueryTiming = enableQueryTiming;
            ClusterElapsedTime = NotRecorded;
            _stopwatch = Stopwatch.StartNew();
        }
Example #37
0
        public string ExtractQuery(IQueryRequest request)
        {
            var fullPath = string.Format("{0}{1}", request.ReportPath, request.ReportName);
            if (!File.Exists(fullPath))
                throw new ArgumentException(string.Format("No report found on path '{0}' with name '{1}'", request.ReportPath, request.ReportName));

            //Load the xml
            var docXml = new XmlDocument();
            docXml.Load(fullPath);
            var root = docXml.FirstChild;
            if (root.NodeType == XmlNodeType.XmlDeclaration)
                root = root.NextSibling;

            //Check that the data set exist
            var xpath = string.Format("//rd:Report/rd:DataSets/rd:DataSet[@Name=\"{0}\"]", request.DataSetName);
            //var xpath = "//Report";

            var nsmgr = new XmlNamespaceManager(docXml.NameTable);
            nsmgr.AddNamespace("rd", root.GetNamespaceOfPrefix(string.Empty));

            var node = docXml.SelectSingleNode(xpath, nsmgr);
            if (node == null)
                throw BuildDataSetNotFoundException(request, docXml, "//rd:Report/rd:DataSets/rd:DataSet", nsmgr);

            //Search in the xml the DataSet and especially the CommandText within this dataset
            xpath = string.Format("//rd:Report/rd:DataSets/rd:DataSet[@Name=\"{0}\"]/rd:Query/rd:CommandText", request.DataSetName);

            node = docXml.SelectSingleNode(xpath, nsmgr);
            if (node != null)
                return node.InnerText; // Weve fond the query

            //If not found then we'll check if it's not a shared dataset
            xpath = string.Format("//rd:Report/rd:DataSets/rd:DataSet[@Name=\"{0}\"]/rd:SharedDataSet/rd:SharedDataSetReference", request.DataSetName);
            node = docXml.SelectSingleNode(xpath, nsmgr);
            if (node == null)
                throw new ArgumentException(string.Format("The data set named '{0}' has been found but no command text or shared dataset reference has been found", request.DataSetName));

            var sharedDataSetName = node.InnerText + ".rsd";
            return ExtractQueryFromSharedDataSet(string.Format("{0}{1}", request.ReportPath, sharedDataSetName));
        }
Example #38
0
        public string ExtractQuery(IQueryRequest request)
        {
            using (var conn = new SqlConnection())
            {
                //create connection and define sql query
                conn.ConnectionString = request.Source;
                var cmd = new SqlCommand();
                cmd.Connection = conn;
                cmd.CommandText = ReadQueryFromContent();

                //create the three parameters for the sql query
                var paramReportPath = new SqlParameter("ReportPath",System.Data.SqlDbType.NVarChar, 425);
                paramReportPath.Value=request.ReportPath;
                cmd.Parameters.Add(paramReportPath);
                var paramReportName = new SqlParameter("ReportName",System.Data.SqlDbType.NVarChar, 425);
                paramReportName.Value=request.ReportName;
                cmd.Parameters.Add(paramReportName);
                //var paramDataSetName = new SqlParameter("DataSetName", System.Data.SqlDbType.NVarChar, 128);
                //paramDataSetName.Value = request.DataSetName;
                //cmd.Parameters.Add(paramDataSetName);

                //execute the command
                conn.Open();
                var dr = cmd.ExecuteReader();
                if (!dr.HasRows)
                    throw new ArgumentException(string.Format("No report found on path '{0}' with name '{1}'", request.ReportPath, request.ReportName));

                var dataSetFound = new List<String>();
                while (dr.Read())
                    if (dr.GetString(2) == request.DataSetName)
                        return dr.GetString(5); //CommandText
                    else
                        dataSetFound.Add(dr.GetString(2));

                if (dataSetFound.Count()>1)
                    throw new ArgumentException(string.Format("The requested dataset ('{2}') wasn't found for the report on path '{0}' with name '{1}'. The datasets for this report are {3}", request.ReportPath, request.ReportName, request.DataSetName, String.Join(", ", dataSetFound.ToArray())));
                else
                    throw new ArgumentException(string.Format("The requested dataset ('{2}') wasn't found for the report on path '{0}' with name '{1}'. The dataset for this report is {3}", request.ReportPath, request.ReportName, request.DataSetName, dataSetFound[0]));
            }
        }
 public override void StartQuery(IQueryRequest queryRequest)
 {
     new ForegroundQuery(this, queryRequest).Start();
 }
 public string ExecuteQuery(IQueryRequest query, Formatting format)
 {
     return JsonConvert.SerializeObject(ExecuteQuery(query), format);
 }
 public IQueryResult<dynamic> ExecuteQuery(IQueryRequest query)
 {
     return ClusterHelper
         .GetBucket(CouchbaseConfigHelper.Instance.Bucket)
         .Query<dynamic>(query);
 }
Example #42
0
 public ForegroundQuery(IRowSourceWrapper rowSource, IQueryRequest queryRequest)
 {
     RowSource = rowSource;
     QueryRequest = queryRequest;
 }
 public abstract void StartQuery(IQueryRequest queryRequest);