示例#1
0
        private async Task <ContextualQueryResultIterator <TInfluxRow> > ExecuteHttpAsync <TInfluxRow>(HttpMethod method, string url, string db, InfluxQueryOptions options, HttpContent content = null)
            where TInfluxRow : new()
        {
            try
            {
                using (var request = new HttpRequestMessage(method, url)
                {
                    Content = (method == HttpMethod.Get ? null : (content == null ? new StringContent("") : content))
                })
                {
                    request.Headers.Authorization = _authzHeader;

                    var response = await _client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead).ConfigureAwait(false);
                    await EnsureSuccessCode(response).ConfigureAwait(false);

                    var objectIterator = await response.Content.GetObjectIteratorAsync().ConfigureAwait(false);

                    var iterator           = new QueryResultIterator <TInfluxRow>(response, objectIterator, this, options, db);
                    var contextualIterator = new ContextualQueryResultIterator <TInfluxRow>(iterator);
                    return(contextualIterator);
                }
            }
            catch (HttpRequestException e)
            {
                throw new InfluxException(Errors.UnknownError, e);
            }
        }
示例#2
0
        internal InfluxChunkedSeries(ContextualQueryResultIterator <TInfluxRow> iterator, string name, IReadOnlyDictionary <string, object> tags)
        {
            _iterator = iterator;

            Name        = name;
            GroupedTags = tags;
        }
示例#3
0
        internal InfluxChunkedResult(ContextualQueryResultIterator <TInfluxRow> iterator, int statementId, string error)
        {
            _iterator = iterator;

            StatementId  = statementId;
            ErrorMessage = error;
            Succeeded    = error == null;
        }
        private void Dispose(bool disposing)
        {
            if (!_disposed)
            {
                if (disposing)
                {
                    if (_iterator != null)
                    {
                        _iterator.Dispose();
                        _iterator = null;
                    }
                }

                _disposed = true;
            }
        }
        /// <summary>
        /// Gets the next result from the result set.
        ///
        /// Null if none are available.
        /// </summary>
        /// <returns></returns>
        public async Task <InfluxChunkedResult <TInfluxRow> > GetNextResultAsync(CancellationToken cancellationToken = default)
        {
            if (_iterator == null)
            {
                return(null);
            }

            if (await _iterator.ConsumeNextResultAsync(cancellationToken).ConfigureAwait(false))
            {
                var currentResult = _iterator.CurrentResult;

                return(new InfluxChunkedResult <TInfluxRow>(
                           _iterator,
                           currentResult.StatementId,
                           currentResult.ErrorMessage));
            }

            // here we can close it
            _iterator.Dispose();
            _iterator = null;

            return(null);
        }
 internal InfluxChunkedResultSet(ContextualQueryResultIterator <TInfluxRow> contextualIterator, InfluxClient client, InfluxQueryOptions options, string db)
 {
     _iterator = contextualIterator;
 }