Added ThrowOnQueryWarning option

src/CouchDB.Driver/CouchClient.cs

@@ -112,19 +112,19 @@ private IFlurlClient GetConfiguredClient() =>
         public ICouchDatabase<TSource> GetDatabase<TSource>(string database, string? discriminator = null) where TSource : CouchDocument
         {
             CheckDatabaseName(database);
-            var queryContext = new QueryContext(Endpoint, database);
+            var queryContext = new QueryContext(Endpoint, database, _options.ThrowOnQueryWarning);
             return new CouchDatabase<TSource>(_flurlClient, _options, queryContext, discriminator);
         }
 
         /// <inheritdoc />
-        public async Task<ICouchDatabase<TSource>> CreateDatabaseAsync<TSource>(string database, 
+        public async Task<ICouchDatabase<TSource>> CreateDatabaseAsync<TSource>(string database,
             int? shards = null, int? replicas = null, bool? partitioned = null, string? discriminator = null, CancellationToken cancellationToken = default)
             where TSource : CouchDocument
         {
             QueryContext queryContext = NewQueryContext(database);
             IFlurlResponse response = await CreateDatabaseAsync(queryContext, shards, replicas, partitioned, cancellationToken)
                 .ConfigureAwait(false);
-            
+
             if (response.IsSuccessful())
             {
                 return new CouchDatabase<TSource>(_flurlClient, _options, queryContext, discriminator);
@@ -167,7 +167,7 @@ public async Task DeleteDatabaseAsync(string database, CancellationToken cancell
                 .SendRequestAsync()
                 .ConfigureAwait(false);
 
-            if (!result.Ok) 
+            if (!result.Ok)
             {
                 throw new CouchException("Something went wrong during the delete.", null, "S");
             }
@@ -433,7 +433,7 @@ private IFlurlRequest NewRequest()
         private QueryContext NewQueryContext(string database)
         {
             CheckDatabaseName(database);
-            return new QueryContext(Endpoint, database);
+            return new QueryContext(Endpoint, database, _options.ThrowOnQueryWarning);
         }
 
         private void CheckDatabaseName(string database)

src/CouchDB.Driver/CouchDatabase.cs

@@ -74,7 +74,7 @@ internal CouchDatabase(IFlurlClient flurlClient, CouchOptions options, QueryCont
         #region Find
 
         /// <inheritdoc />
-        public Task<TSource?> FindAsync(string docId, bool withConflicts = false, CancellationToken cancellationToken = default) 
+        public Task<TSource?> FindAsync(string docId, bool withConflicts = false, CancellationToken cancellationToken = default)
             => FindAsync(docId, new FindOptions { Conflicts = withConflicts }, cancellationToken);
 
         /// <inheritdoc />
@@ -161,6 +161,10 @@ private async Task<List<TSource>> SendQueryAsync(Func<IFlurlRequest, Task<IFlurl
                 .SendRequestAsync()
                 .ConfigureAwait(false);
 
+            if (this._options.ThrowOnQueryWarning && !String.IsNullOrEmpty(findResult.Warning))
+            {
+                throw new CouchDBQueryWarningException(findResult.Warning);
+            }
             var documents = findResult.Docs.ToList();
 
             foreach (TSource document in documents)
@@ -433,7 +437,7 @@ public async Task<ChangesFeedResponse<TSource>> GetChangesAsync(ChangesFeedOptio
                     .ConfigureAwait(false)
                 : await request.QueryWithFilterAsync<TSource>(_queryProvider, filter, cancellationToken)
                     .ConfigureAwait(false);
-            
+
             if (string.IsNullOrWhiteSpace(_discriminator))
             {
                 return response;
@@ -468,7 +472,7 @@ public async IAsyncEnumerable<ChangesFeedResponseResult<TSource>> GetContinuousC
                         .ConfigureAwait(false)
                     : await request.QueryContinuousWithFilterAsync<TSource>(_queryProvider, filter, cancellationToken)
                         .ConfigureAwait(false);
-                
+
                 await foreach (var line in stream.ReadLinesAsync(cancellationToken))
                 {
                     if (string.IsNullOrEmpty(line))

src/CouchDB.Driver/DTOs/FindResult.cs

@@ -16,6 +16,9 @@ internal class FindResult<T>
 
         [JsonProperty("execution_stats")]
         public ExecutionStats ExecutionStats { get; internal set; }
+
+        [JsonProperty("warning")]
+        public string Warning { get; internal set; }
     }
 }
 #nullable restore

src/CouchDB.Driver/Exceptions/CouchDBQueryWarningException.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace CouchDB.Driver.Exceptions
+{
+    /// <summary>
+    /// The exception that is thrown if the query returns a warning.
+    /// </summary>
+    public class CouchDBQueryWarningException : Exception
+    {
+        public CouchDBQueryWarningException(string message) : base(message) { }
+    }
+}

src/CouchDB.Driver/Options/CouchOptions.cs

@@ -27,14 +27,16 @@ public abstract class CouchOptions
         internal bool PluralizeEntities { get; set; }
         internal DocumentCaseType DocumentsCaseType { get; set; }
         internal PropertyCaseType PropertiesCase { get; set; }
-        
+
         internal string? DatabaseSplitDiscriminator { get; set; }
         internal NullValueHandling? NullValueHandling { get; set; }
         internal bool LogOutOnDispose { get; set; }
 
         internal Func<HttpRequestMessage, X509Certificate2, X509Chain, SslPolicyErrors, bool>? ServerCertificateCustomValidationCallback { get; set; }
         internal Action<ClientFlurlHttpSettings>? ClientFlurlHttpSettingsAction { get; set; }
 
+        internal bool ThrowOnQueryWarning { get; set; }
+
         internal CouchOptions()
         {
             AuthenticationType = AuthenticationType.None;

src/CouchDB.Driver/Options/CouchOptionsBuilder.cs

@@ -95,6 +95,12 @@ public virtual CouchOptionsBuilder UseBasicAuthentication(string username, strin
             return this;
         }
 
+        public virtual CouchOptionsBuilder ThrowOnQueryWarning()
+        {
+            Options.ThrowOnQueryWarning = true;
+            return this;
+        }
+
         /// <summary>
         /// Enables cookie authentication. 
         /// For cookie authentication (RFC 2109) CouchDB generates a token that the client can use for the next few requests to CouchDB. Tokens are valid until a timeout.

src/CouchDB.Driver/Query/QueryContext.cs

@@ -8,11 +8,14 @@ public class QueryContext
         public string DatabaseName { get; set; }
         public string EscapedDatabaseName { get; set; }
 
-        public QueryContext(Uri endpoint, string databaseName)
+        public bool ThrowOnQueryWarning { get; set; }
+
+        public QueryContext(Uri endpoint, string databaseName, bool throwOnQueryWarning)
         {
             Endpoint = endpoint;
             DatabaseName = databaseName;
             EscapedDatabaseName = Uri.EscapeDataString(databaseName);
+            ThrowOnQueryWarning = throwOnQueryWarning;
         }
     }
 }

src/CouchDB.Driver/Query/QuerySender.cs

@@ -4,6 +4,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using CouchDB.Driver.DTOs;
+using CouchDB.Driver.Exceptions;
 using CouchDB.Driver.Helpers;
 using CouchDB.Driver.Types;
 using Flurl.Http;
@@ -57,13 +58,22 @@ private async Task<CouchList<TItem>> ToListAsync<TItem>(string body, Cancellatio
             return new CouchList<TItem>(result.Docs.ToList(), result.Bookmark, result.ExecutionStats);
         }
 
-        private Task<FindResult<TItem>> SendAsync<TItem>(string body, CancellationToken cancellationToken) =>
-            _client
+        private async Task<FindResult<TItem>> SendAsync<TItem>(string body, CancellationToken cancellationToken)
+        {
+            var findResult = await _client
                 .Request(_queryContext.Endpoint)
                 .AppendPathSegments(_queryContext.DatabaseName, "_find")
                 .WithHeader("Content-Type", "application/json")
                 .PostStringAsync(body, cancellationToken)
                 .ReceiveJson<FindResult<TItem>>()
                 .SendRequestAsync();
+
+            if (this._queryContext.ThrowOnQueryWarning && !String.IsNullOrEmpty(findResult.Warning))
+            {
+                throw new CouchDBQueryWarningException(findResult.Warning);
+            }
+
+            return findResult;
+        }
     }
 }

tests/CouchDB.Driver.E2ETests/Client_Tests.cs

@@ -6,14 +6,15 @@
 using System.Threading.Tasks;
 using CouchDB.Driver.E2ETests;
 using CouchDB.Driver.E2ETests.Models;
+using CouchDB.Driver.Exceptions;
 using CouchDB.Driver.Extensions;
 using CouchDB.Driver.Local;
 using Xunit;
 
 namespace CouchDB.Driver.E2E
 {
     [Trait("Category", "Integration")]
-    public class ClientTests: IAsyncLifetime
+    public class ClientTests : IAsyncLifetime
     {
         private ICouchClient _client;
         private ICouchDatabase<Rebel> _rebels;
@@ -152,7 +153,7 @@ public async Task Crud_SpecialCharacters()
         public async Task Users()
         {
             var users = await _client.GetOrCreateUsersDatabaseAsync();
-            
+
             CouchUser luke = await users.AddAsync(new CouchUser(name: "luke", password: "lasersword"));
             Assert.Equal("luke", luke.Name);
 
@@ -266,5 +267,41 @@ public async Task LocalDocuments()
             var containsId = docs.Select(d => d.Id).Contains("_local/" + docId);
             Assert.True(containsId);
         }
+
+        [Fact]
+        public async Task ThrowOnQueryWarning()
+        {
+            await using var context = new MyDeathStarContextWithQueryWarning();
+            // There is an index for Name and Surname so it should not cause a warning
+            await context.Rebels.Where(r => r.Name == "Luke" && r.Surname == "Skywalker").ToListAsync();
+            try
+            {
+                // There is no index for Age so it should cause a warning
+                await context.Rebels.Where(r => r.Age == 19).ToListAsync();
+                Assert.Fail("Expected exception not thrown");
+            }
+            catch (CouchDBQueryWarningException e)
+            {
+                Assert.Equal("No matching index found, create an index to optimize query time.", e.Message);
+            }
+
+            var client = new CouchClient("http://localhost:5984", c =>
+                c.UseBasicAuthentication("admin", "admin")
+                    .ThrowOnQueryWarning());
+            var crebels = client.GetDatabase<Rebel>();
+            // There is an index for Name and Surname so it should not cause a warning
+            await crebels.QueryAsync(@"{""selector"":{""$and"":[{""name"":""Luke""},{""surname"":""Skywalker""}]}}");
+            try
+            {
+                // There is no index for Age so it should cause a warning
+                await crebels.QueryAsync(@"{""selector"":{""age"":""19""}}");
+                Assert.Fail("Expected exception not thrown");
+            }
+            catch (CouchDBQueryWarningException e)
+            {
+                Assert.Equal("No matching index found, create an index to optimize query time.", e.Message);
+            }
+
+        }
     }
 }

tests/CouchDB.Driver.E2ETests/MyDeathStarContext.cs

@@ -1,4 +1,4 @@
-using CouchDB.Driver.E2ETests.Models;
+using CouchDB.Driver.E2ETests.Models;
 using CouchDB.Driver.Options;
 
 namespace CouchDB.Driver.E2ETests
@@ -48,4 +48,27 @@ protected override void OnDatabaseCreating(CouchDatabaseBuilder databaseBuilder)
                     .ThenByDescending(r => r.Name));
         }
     }
+
+    public class MyDeathStarContextWithQueryWarning : CouchContext
+    {
+        public CouchDatabase<Rebel> Rebels { get; set; }
+
+        protected override void OnConfiguring(CouchOptionsBuilder optionsBuilder)
+        {
+            optionsBuilder
+                    .UseEndpoint("http://localhost:5984/")
+                    .EnsureDatabaseExists()
+                    .UseBasicAuthentication(username: "admin", password: "admin")
+                    .ThrowOnQueryWarning();
+        }
+
+        protected override void OnDatabaseCreating(CouchDatabaseBuilder databaseBuilder)
+        {
+            databaseBuilder.Document<Rebel>()
+                    .HasIndex("surnames_index", builder => builder
+                            .IndexBy(r => r.Surname)
+                            .ThenBy(r => r.Name));
+        }
+    }
+
 }