public static void WriteIndexQuery(this BlittableJsonTextWriter writer, JsonOperationContext context, IIndexQuery query)
        {
            var indexQuery = query as IndexQueryServerSide;

            if (indexQuery != null)
            {
                writer.WriteIndexQuery(context, indexQuery);
                return;
            }

            var moreLikeThisQuery = query as MoreLikeThisQueryServerSide;

            if (moreLikeThisQuery != null)
            {
                writer.WriteMoreLikeThisQuery(context, moreLikeThisQuery);
                return;
            }

            var facetQuery = query as FacetQuery;

            if (facetQuery != null)
            {
                writer.WriteFacetQuery(context, facetQuery);
                return;
            }

            throw new NotSupportedException($"Not supported query type: {query.GetType()}");
        }
Пример #2
0
        public Task RunningQueries()
        {
            var indexes = Database
                          .IndexStore
                          .GetIndexes()
                          .ToList();

            DocumentsOperationContext context;

            using (ContextPool.AllocateOperationContext(out context))
                using (var writer = new BlittableJsonTextWriter(context, ResponseBodyStream()))
                {
                    writer.WriteStartObject();
                    foreach (var index in indexes)
                    {
                        writer.WritePropertyName(index.Name);
                        writer.WriteStartArray();

                        var isFirstInternal = true;
                        foreach (var query in index.CurrentlyRunningQueries)
                        {
                            if (isFirstInternal == false)
                            {
                                writer.WriteComma();
                            }

                            isFirstInternal = false;

                            writer.WriteStartObject();

                            writer.WritePropertyName((nameof(query.Duration)));
                            writer.WriteString(query.Duration.ToString());
                            writer.WriteComma();

                            writer.WritePropertyName((nameof(query.QueryId)));
                            writer.WriteInteger(query.QueryId);
                            writer.WriteComma();

                            writer.WritePropertyName((nameof(query.StartTime)));
                            writer.WriteString(query.StartTime.GetDefaultRavenFormat());
                            writer.WriteComma();

                            writer.WritePropertyName((nameof(query.QueryInfo)));
                            writer.WriteIndexQuery(context, query.QueryInfo);

                            writer.WriteEndObject();
                        }

                        writer.WriteEndArray();
                    }

                    writer.WriteEndObject();
                }

            return(Task.CompletedTask);
        }
Пример #3
0
        public override HttpRequestMessage CreateRequest(JsonOperationContext ctx, ServerNode node, out string url)
        {
            var request = new HttpRequestMessage
            {
                Method  = HttpMethod.Post,
                Content = new BlittableJsonContent(stream =>
                {
                    using (var writer = new BlittableJsonTextWriter(ctx, stream))
                    {
                        writer.WriteIndexQuery(_conventions, ctx, _indexQuery);
                    }
                })
            };

            url = $"{node.Url}/databases/{node.Database}/streams/queries";
            return(request);
        }
Пример #4
0
        public override HttpRequestMessage CreateRequest(JsonOperationContext ctx, ServerNode node, out string url)
        {
            CanCache = _indexQuery.DisableCaching == false;

            // we won't allow aggressive caching of queries with WaitForNonStaleResults
            CanCacheAggressively = CanCache && _indexQuery.WaitForNonStaleResults == false;

            var path = new StringBuilder(node.Url)
                       .Append("/databases/")
                       .Append(node.Database)
                       .Append("/queries?queryHash=")
                       // we need to add a query hash because we are using POST queries
                       // so we need to unique parameter per query so the query cache will
                       // work properly
                       .Append(_indexQuery.GetQueryHash(ctx));

            if (_metadataOnly)
            {
                path.Append("&metadataOnly=true");
            }

            if (_indexEntriesOnly)
            {
                path.Append("&debug=entries");
            }

            var request = new HttpRequestMessage
            {
                Method  = HttpMethod.Post,
                Content = new BlittableJsonContent(stream =>
                {
                    // this is here to catch people closing the session before the ToListAsync() completes
                    _session.AssertNotDisposed();
                    using (var writer = new BlittableJsonTextWriter(ctx, stream))
                    {
                        writer.WriteIndexQuery(_conventions, ctx, _indexQuery);
                    }
                }
                                                   )
            };

            url = path.ToString();
            return(request);
        }
Пример #5
0
            public override HttpRequestMessage CreateRequest(JsonOperationContext ctx, ServerNode node, out string url)
            {
                var path = new StringBuilder(node.Url)
                           .Append("/databases/")
                           .Append(node.Database)
                           .Append("/queries")
                           .Append("?allowStale=")
                           .Append(_options.AllowStale)
                           .Append("&maxOpsPerSec=")
                           .Append(_options.MaxOpsPerSecond)
                           .Append("&details=")
                           .Append(_options.RetrieveDetails);

                if (_options.StaleTimeout != null)
                {
                    path
                    .Append("&staleTimeout=")
                    .Append(_options.StaleTimeout.Value);
                }

                var request = new HttpRequestMessage
                {
                    Method  = HttpMethods.Patch,
                    Content = new BlittableJsonContent(stream =>
                    {
                        using (var writer = new BlittableJsonTextWriter(ctx, stream))
                        {
                            writer.WriteStartObject();

                            writer.WritePropertyName("Query");
                            writer.WriteIndexQuery(_conventions, ctx, _queryToUpdate);
                            writer.WriteEndObject();
                        }
                    }
                                                       )
                };

                url = path.ToString();
                return(request);
            }
Пример #6
0
        public override HttpRequestMessage CreateRequest(JsonOperationContext ctx, ServerNode node, out string url)
        {
            var path = new StringBuilder(node.Url)
                       .Append("/databases/")
                       .Append(node.Database)
                       .Append("/queries?debug=explain");

            var request = new HttpRequestMessage
            {
                Method  = HttpMethod.Post,
                Content = new BlittableJsonContent(stream =>
                {
                    using (var writer = new BlittableJsonTextWriter(ctx, stream))
                    {
                        writer.WriteIndexQuery(_conventions, ctx, _indexQuery);
                    }
                }
                                                   )
            };

            url = path.ToString();
            return(request);
        }
Пример #7
0
 public void WriteContent(BlittableJsonTextWriter writer, JsonOperationContext context)
 {
     writer.WriteIndexQuery(_conventions, context, _query);
 }