public async Task<IEnumerable<DocumentEntity<T>>> GetAllDocumentsAsync<T>(CosmosDbQuery cosmosDbQuery, int itemsPerPage = 1000) where T : IIdentifiable
        {
            Guard.ArgumentNotNull(cosmosDbQuery, nameof(cosmosDbQuery));

            QueryRequestOptions queryRequestOptions = GetQueryRequestOptions(itemsPerPage);

            return await Results<DocumentEntity<T>>(cosmosDbQuery.CosmosQueryDefinition, queryRequestOptions);
        }
Exemple #2
0
        private async Task <IEnumerable <T> > ResultsFromQueryAndOptions <T>(CosmosDbQuery cosmosDbQuery, Func <List <T>, Task> batchAction, QueryRequestOptions queryOptions)
        {
            FeedIterator <T> query = RepositoryContainer.GetItemQueryIterator <T>(
                queryDefinition: cosmosDbQuery.CosmosQueryDefinition,
                requestOptions: queryOptions);

            return(await ResultsFromFeedIterator(query, batchAction, queryOptions.MaxItemCount ?? 0));
        }
        public async Task<IEnumerable<dynamic>> DynamicQuery(CosmosDbQuery cosmosDbQuery, int itemsPerPage = 1000)
        {
            Guard.ArgumentNotNull(cosmosDbQuery, nameof(cosmosDbQuery));

            QueryRequestOptions queryRequestOptions = GetDefaultQueryRequestOptions(itemsPerPage: itemsPerPage);

            return await ResultsFromQueryAndOptions<dynamic>(cosmosDbQuery, queryRequestOptions);
        }
Exemple #4
0
        private async Task <IEnumerable <T> > ResultsFromQueryAndOptions <T>(CosmosDbQuery cosmosDbQuery, QueryRequestOptions queryOptions, int?maxItemCount = null)
        {
            FeedIterator <T> query = RepositoryContainer.GetItemQueryIterator <T>(
                queryDefinition: cosmosDbQuery.CosmosQueryDefinition,
                requestOptions: queryOptions);

            return(await ResultsFromFeedIterator(query, maxItemCount));
        }
        public async Task<IEnumerable<string>> QueryAsJsonAsync(CosmosDbQuery cosmosDbQuery, int itemsPerPage = -1, int? maxItemCount = null)
        {
            Guard.ArgumentNotNull(cosmosDbQuery, nameof(cosmosDbQuery));

            QueryRequestOptions queryRequestOptions = GetQueryRequestOptions(GetEffectivePageSize(itemsPerPage, maxItemCount));

            IEnumerable<Document> documents = await ResultsFromQueryAndOptions<Document>(cosmosDbQuery, queryRequestOptions, maxItemCount);

            return JsonFromDocuments(documents);
        }
        public async Task<IEnumerable<T>> RawQuery<T>(CosmosDbQuery cosmosDbQuery, int itemsPerPage = -1, int? maxItemCount = null)
        {
            Guard.ArgumentNotNull(cosmosDbQuery, nameof(cosmosDbQuery));

            QueryRequestOptions queryOptions = GetDefaultQueryRequestOptions(itemsPerPage: itemsPerPage,
                maxBufferedItemCount: 50,
                maxConcurrency: 100);

            return await ResultsFromQueryAndOptions<T>(cosmosDbQuery, queryOptions, maxItemCount);
        }
        public ICosmosDbFeedIterator GetFeedIterator(CosmosDbQuery cosmosDbQuery, int itemsPerPage = -1, int? maxItemCount = null)
        {
            Guard.ArgumentNotNull(cosmosDbQuery, nameof(cosmosDbQuery));

            QueryRequestOptions queryOptions = GetQueryRequestOptions(GetEffectivePageSize(itemsPerPage, maxItemCount));

            return new CosmosDbFeedIterator(RepositoryContainer.GetItemQueryStreamIterator(
                queryDefinition: cosmosDbQuery.CosmosQueryDefinition,
                requestOptions: queryOptions));
        }
        public async Task<IEnumerable<T>> QuerySql<T>(CosmosDbQuery cosmosDbQuery, int itemsPerPage = -1, int? maxItemCount = null) where T : IIdentifiable
        {
            Guard.ArgumentNotNull(cosmosDbQuery, nameof(cosmosDbQuery));

            QueryRequestOptions queryOptions = GetQueryRequestOptions(GetEffectivePageSize(itemsPerPage, maxItemCount));

            IEnumerable<DocumentEntity<T>> results = await ResultsFromQueryAndOptions<DocumentEntity<T>>(cosmosDbQuery, queryOptions, maxItemCount);

            return results.Select(c => c.Content);
        }
        public async Task<IEnumerable<T>> QueryPartitionedEntity<T>(CosmosDbQuery cosmosDbQuery, int itemsPerPage = -1, int? maxItemCount = null, string partitionKey = null) where T : IIdentifiable
        {
            Guard.ArgumentNotNull(cosmosDbQuery, nameof(cosmosDbQuery));

            QueryRequestOptions queryRequestOptions = GetDefaultQueryRequestOptions(itemsPerPage: GetEffectivePageSize(itemsPerPage, maxItemCount));
            queryRequestOptions.PartitionKey = new PartitionKey(partitionKey);

            IEnumerable<DocumentEntity<T>> documentResults = await ResultsFromQueryAndOptions<DocumentEntity<T>>(cosmosDbQuery, queryRequestOptions, maxItemCount);

            return documentResults.Select(x => x.Content);
        }
        public async Task<DocumentEntity<T>> ReadDocumentByIdAsync<T>(string id) where T : IIdentifiable
        {
            Guard.IsNullOrWhiteSpace(id, nameof(id));

            CosmosDbQuery cosmosDbQuery = new CosmosDbQuery
            {
                QueryText = @"SELECT *
                            FROM    c 
                            WHERE   c.documentType = @documentType 
                                    AND c.id = @id",
                Parameters = new[]
                {
                    new CosmosDbQueryParameter("@documentType", GetDocumentType<T>()),
                    new CosmosDbQueryParameter("@id", id)
                }
            };

            return (await Results<DocumentEntity<T>>(cosmosDbQuery.CosmosQueryDefinition)).SingleOrDefault();
        }
 private async Task<IEnumerable<T>> ResultsFromQueryAndOptions<T>(CosmosDbQuery cosmosDbQuery, Func<List<T>, Task> batchAction, QueryRequestOptions queryOptions)
 {
     return await Results(cosmosDbQuery.CosmosQueryDefinition, queryOptions, batchAction, queryOptions.MaxItemCount ?? 0);
 }
 private async Task<IEnumerable<T>> ResultsFromQueryAndOptions<T>(CosmosDbQuery cosmosDbQuery, QueryRequestOptions queryOptions, int? maxItemCount = null)
 {
     return await Results<T>(cosmosDbQuery.CosmosQueryDefinition, queryOptions , maxItemCount);
 }
        public async Task DocumentsBatchProcessingAsync<T>(Func<List<T>, Task> persistBatchToIndex, CosmosDbQuery cosmosDbQuery, int itemsPerPage = 1000) where T : IIdentifiable
        {
            QueryRequestOptions queryRequestOptions = GetQueryRequestOptions(itemsPerPage);

            await ResultsFromQueryAndOptions(cosmosDbQuery, persistBatchToIndex, queryRequestOptions);
        }
        public async Task<IEnumerable<dynamic>> DynamicQueryPartitionedEntity<dynamic>(CosmosDbQuery cosmosDbQuery, string partitionEntityId = null)
        {
            Guard.ArgumentNotNull(cosmosDbQuery, nameof(cosmosDbQuery));

            QueryRequestOptions queryRequestOptions = GetDefaultQueryRequestOptions();
            queryRequestOptions.PartitionKey = new PartitionKey(partitionEntityId);

            return await ResultsFromQueryAndOptions<dynamic>(cosmosDbQuery, queryRequestOptions);
        }