public async Task <FacetedQueryResult> ExecuteFacetedQuery(IndexQueryServerSide query, long?existingResultEtag, DocumentsOperationContext documentsContext, OperationCancelToken token) { if (query.Metadata.IsDynamic) { throw new InvalidQueryException("Facet query must be executed against static index.", query.Metadata.QueryText, query.QueryParameters); } ObjectDisposedException lastException = null; for (var i = 0; i < NumberOfRetries; i++) { try { documentsContext.CloseTransaction(); var sw = Stopwatch.StartNew(); var result = await _static.ExecuteFacetedQuery(query, existingResultEtag, documentsContext, token); result.DurationInMs = (long)sw.Elapsed.TotalMilliseconds; return(result); } catch (ObjectDisposedException e) { if (Database.DatabaseShutdown.IsCancellationRequested) { throw; } lastException = e; } } throw CreateRetriesFailedException(lastException); }
public override async Task ExecuteStreamQuery(IndexQueryServerSide query, DocumentsOperationContext documentsContext, HttpResponse response, IStreamDocumentQueryResultWriter writer, OperationCancelToken token) { ObjectDisposedException lastException = null; for (var i = 0; i < NumberOfRetries; i++) { try { documentsContext.CloseTransaction(); await GetRunner(query).ExecuteStreamQuery(query, documentsContext, response, writer, token); return; } catch (ObjectDisposedException e) { if (Database.DatabaseShutdown.IsCancellationRequested) { throw; } lastException = e; } } throw CreateRetriesFailedException(lastException); }
public async Task <bool> WaitForNonStaleResults() { if (_context.Transaction == null || _context.Transaction.Disposed) { _context.OpenReadTransaction(); } var etag = DocumentsStorage.ReadLastEtag(_context.Transaction.InnerTransaction); var queryDuration = Stopwatch.StartNew(); var indexNamesGatherer = new GraphQueryIndexNamesGatherer(); indexNamesGatherer.Visit(RootQueryStep); var indexes = new List <Index>(); var indexNames = new HashSet <string>(StringComparer.OrdinalIgnoreCase); var indexWaiters = new Dictionary <Index, (IndexQueryServerSide, AsyncWaitForIndexing)>(); var queryTimeout = _query.WaitForNonStaleResultsTimeout ?? Index.DefaultWaitForNonStaleResultsTimeout; foreach (var indexName in indexNamesGatherer.Indexes) { if (indexNames.Add(indexName) == false) { continue; } var index = _database.IndexStore.GetIndex(indexName); indexes.Add(index); indexWaiters.Add(index, (_query, new AsyncWaitForIndexing(queryDuration, queryTimeout, index))); } foreach (var qqs in indexNamesGatherer.QueryStepsWithoutExplicitIndex) { // we need to close the transaction since the DynamicQueryRunner.MatchIndex // expects that the transaction will be closed _context.CloseTransaction(); //this will ensure that query step has relevant index //if needed, this will create auto-index var query = new IndexQueryServerSide(qqs.Query.ToString(), qqs.QueryParameters); var index = await _dynamicQueryRunner.MatchIndex(query, true, null, _database.DatabaseShutdown); if (indexNames.Add(index.Name) == false) { continue; } indexes.Add(index); indexWaiters.Add(index, (_query, new AsyncWaitForIndexing(queryDuration, queryTimeout, index))); } return(await WaitForNonStaleResultsInternal(etag, indexes, indexWaiters)); }
public override async Task <DocumentQueryResult> ExecuteQuery(IndexQueryServerSide query, DocumentsOperationContext documentsContext, long?existingResultEtag, OperationCancelToken token) { ObjectDisposedException lastException = null; for (var i = 0; i < NumberOfRetries; i++) { try { documentsContext.CloseTransaction(); Stopwatch sw = null; QueryTimingsScope scope; DocumentQueryResult result; using (scope = query.Timings?.Start()) { if (scope == null) { sw = Stopwatch.StartNew(); } result = await GetRunner(query).ExecuteQuery(query, documentsContext, existingResultEtag, token); } result.DurationInMs = sw != null ? (long)sw.Elapsed.TotalMilliseconds : (long)scope.Duration.TotalMilliseconds; return(result); } catch (ObjectDisposedException e) { if (Database.DatabaseShutdown.IsCancellationRequested) { throw; } lastException = e; } } throw CreateRetriesFailedException(lastException); }
public override async Task <IOperationResult> ExecutePatchQuery(IndexQueryServerSide query, QueryOperationOptions options, PatchRequest patch, BlittableJsonReaderObject patchArgs, DocumentsOperationContext context, Action <IOperationProgress> onProgress, OperationCancelToken token) { ObjectDisposedException lastException = null; for (var i = 0; i < NumberOfRetries; i++) { try { context.CloseTransaction(); return(await GetRunner(query).ExecutePatchQuery(query, options, patch, patchArgs, context, onProgress, token)); } catch (ObjectDisposedException e) { if (Database.DatabaseShutdown.IsCancellationRequested) { throw; } lastException = e; } } throw CreateRetriesFailedException(lastException); }
public override async Task <IndexEntriesQueryResult> ExecuteIndexEntriesQuery(IndexQueryServerSide query, DocumentsOperationContext context, long?existingResultEtag, OperationCancelToken token) { ObjectDisposedException lastException = null; for (var i = 0; i < NumberOfRetries; i++) { try { context.CloseTransaction(); return(await GetRunner(query).ExecuteIndexEntriesQuery(query, context, existingResultEtag, token)); } catch (ObjectDisposedException e) { if (Database.DatabaseShutdown.IsCancellationRequested) { throw; } lastException = e; } } throw CreateRetriesFailedException(lastException); }
public async Task <SuggestionQueryResult> ExecuteSuggestionQuery(IndexQueryServerSide query, DocumentsOperationContext context, long?existingResultEtag, OperationCancelToken token) { if (query.Metadata.IsDynamic) { throw new InvalidQueryException("Suggestion query must be executed against static index.", query.Metadata.QueryText, query.QueryParameters); } ObjectDisposedException lastException = null; for (var i = 0; i < NumberOfRetries; i++) { try { context.CloseTransaction(); var sw = Stopwatch.StartNew(); if (query.Metadata.SelectFields.Length != 1 || query.Metadata.SelectFields[0].IsSuggest == false) { throw new InvalidQueryException("Suggestion query must have one suggest token in SELECT.", query.Metadata.QueryText, query.QueryParameters); } var selectField = (SuggestionField)query.Metadata.SelectFields[0]; var index = GetIndex(query.Metadata.IndexName); var indexDefinition = index.GetIndexDefinition(); if (indexDefinition.Fields.TryGetValue(selectField.Name, out IndexFieldOptions field) == false) { throw new InvalidOperationException($"Index '{query.Metadata.IndexName}' does not have a field '{selectField.Name}'."); } if (field.Suggestions == null) { throw new InvalidOperationException($"Index '{query.Metadata.IndexName}' does not have suggestions configured for field '{selectField.Name}'."); } if (field.Suggestions.Value == false) { throw new InvalidOperationException($"Index '{query.Metadata.IndexName}' have suggestions explicitly disabled for field '{selectField.Name}'."); } if (existingResultEtag.HasValue) { var etag = index.GetIndexEtag(query.Metadata); if (etag == existingResultEtag.Value) { return(SuggestionQueryResult.NotModifiedResult); } } var result = await index.SuggestionQuery(query, context, token); result.DurationInMs = (int)sw.Elapsed.TotalMilliseconds; return(result); } catch (ObjectDisposedException e) { if (Database.DatabaseShutdown.IsCancellationRequested) { throw; } lastException = e; } } throw CreateRetriesFailedException(lastException); }
private async Task <IOperationResult> ExecuteOperation(string indexName, IndexQueryServerSide query, QueryOperationOptions options, DocumentsOperationContext context, Action <DeterminateProgress> onProgress, Action <string> action, OperationCancelToken token) { var index = GetIndex(indexName); if (index.Type.IsMapReduce()) { throw new InvalidOperationException("Cannot execute bulk operation on Map-Reduce indexes."); } query = ConvertToOperationQuery(query, options); const int BatchSize = 1024; RavenTransaction tx = null; var operationsInCurrentBatch = 0; List <string> resultKeys; try { var results = await index.Query(query, context, token).ConfigureAwait(false); if (options.AllowStale == false && results.IsStale) { throw new InvalidOperationException("Cannot perform bulk operation. Query is stale."); } resultKeys = new List <string>(results.Results.Count); foreach (var document in results.Results) { resultKeys.Add(document.Key.ToString()); } } finally //make sure to close tx if DocumentConflictException is thrown { context.CloseTransaction(); } var progress = new DeterminateProgress { Total = resultKeys.Count, Processed = 0 }; onProgress(progress); using (var rateGate = options.MaxOpsPerSecond.HasValue ? new RateGate(options.MaxOpsPerSecond.Value, TimeSpan.FromSeconds(1)) : null) { foreach (var document in resultKeys) { if (rateGate != null && rateGate.WaitToProceed(0) == false) { using (tx) { tx?.Commit(); } tx = null; rateGate.WaitToProceed(); } if (tx == null) { operationsInCurrentBatch = 0; tx = context.OpenWriteTransaction(); } action(document); operationsInCurrentBatch++; progress.Processed++; if (progress.Processed % 128 == 0) { onProgress(progress); } if (operationsInCurrentBatch < BatchSize) { continue; } using (tx) { tx.Commit(); } tx = null; } } using (tx) { tx?.Commit(); } return(new BulkOperationResult { Total = progress.Total }); }
public void CloseTransaction() { Documents.CloseTransaction(); Server?.CloseTransaction(); }