Sobre o que estou aprendendo Couchbase é que, embora seu objetivo seja fornecer padrões sensatos, ele também oferece opções para fazer concessões. A compensação na qual vou me concentrar nesta postagem do blog é a consistência de varredura para consultas N1QL.
O Couchbase 4.5 apresenta um novo Opção de consistência de varredura: AtPlus. Isso se junta às opções existentes para formar um total de três:
-
NotBounded (padrão)
-
AtPlus (novo no Couchbase Server 4.5)
-
RequestPlus
Esta postagem do blog analisará o NotBounded e o RequestPlus, além de apresentar o AtPlus. Também fornecerei um exemplo de código que você pode usar para experimentar os três.
Não limitado
Esse é o comportamento padrão.
Uma consulta N1QL que esteja usando a consistência de varredura "Not Bounded" significa que ela não esperará que nenhum índice termine de ser atualizado antes de executar a consulta e retornar os resultados. Digamos que você tenha os documentos A, B e C em um bucket. No momento da consulta, apenas A e B estão indexados. Com Not Bounded, somente os documentos A e B serão retornados.
Como a consulta não está esperando por nenhuma indexação, essa é a melhor opção de desempenho. O documento C aparecerá assim que for indexado. Isso não deve demorar muito, mas se você tiver acabado de criar C, por exemplo, e depois consultar imediatamente uma lista completa de documentos, C poderá não aparecer. Para demonstrar com o amostra de viagem balde:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
private static void NotBoundedExample() { Console.WriteLine("========= NonBounded (default)"); // get the current count var result1 = _bucket.Query("SELECT COUNT(1) as airportCount FROM `travel-sample` WHERE type='airport'") .Rows.First(); Console.WriteLine($"Initial count: {result1.airportCount}"); // insert a new airport var doc = new Document { Id = "ScanConsistency::airport::" + _random.Next(10000), Content = new { type = "airport" } }; _bucket.Insert(doc); // get the count again var result2 = _bucket.Query("SELECT COUNT(1) as airportCount FROM `travel-sample` WHERE type='airport'") .Rows.First(); Console.WriteLine($"Count after insert: {result2.airportCount}"); // wait a few seconds and get the count again Console.Write("Waiting for 5 seconds..."); Thread.Sleep(5000); var result3 = _bucket.Query("SELECT COUNT(1) as airportCount FROM `travel-sample` WHERE type='airport'") .Rows.First(); Console.WriteLine($"Count after waiting: {result3.airportCount}"); } |
O que eu esperaria ver ao executar esse código é:
-
Contagem inicial: N -
Contagem após a inserção: N(ainda) -
Em espera
-
Contagem após a espera: N+1
Defino o tempo de espera em 5 segundos, o que provavelmente é um exagero. Uso o Thread.Sleep apenas para fins de demonstração, mas é óbvio que essa é uma tática complicada para um aplicativo real. Isso nos leva ao RequestPlus.
RequestPlus
Essa opção de consistência de varredura fornece quase o oposto de Not Bounded. Ela aguardará até que todas as alterações de documentos e atualizações de índices (até o momento em que a consulta foi executada) sejam processadas antes de executar a consulta.
Veja a seguir um exemplo simplificado da sequência de eventos ao usar o RequestPlus
-
O documento C é criado
-
A consulta N1QL para obter todos os documentos é executada (A, B, C existem todos no bucket)
-
A consulta N1QL é colocada em espera porque pelo menos um documento precisa ser indexado (documento C).
-
O processo de indexação foi concluído. O documento C agora está indexado.
-
A consulta N1QL é executada, retornando A,B,C.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
private static void RequestPlusExample() { Console.WriteLine("========= RequestPlus"); // get the current count var result1 = _bucket.Query("SELECT COUNT(1) as airportCount FROM `travel-sample` WHERE type='airport'") .Rows.First(); Console.WriteLine($"Initial count: {result1.airportCount}"); // insert a new airport var doc = new Document { Id = "ScanConsistency::airport::" + _random.Next(10000), Content = new { type = "airport" } }; _bucket.Insert(doc); // get the count again var request = QueryRequest.Create("SELECT COUNT(1) as airportCount FROM `travel-sample` WHERE type='airport'"); request.ScanConsistency(ScanConsistency.RequestPlus); var result2 = _bucket.Query(request).Rows.First(); Console.WriteLine($"Count after insert with RequestPlus: {result2.airportCount}"); } |
Isso nos dá integridade nos resultados da consulta, às custas do desempenho. Em alguns casos, não faz sentido esperar pelo tudo para ser indexado. E isso nos leva ao AtPlus.
AtPlus (novo no Couchbase 4.5)
Essa opção de consistência de varredura oferece um meio-termo entre RequestPlus e Not Bounded. Ela também é uma nova opção de consistência de varredura para o Couchbase 4.5.
Com o AtPlus, você terá que trabalhar um pouco mais em seu código, mas, em troca, terá um desempenho melhor do que com o RequestPlus. Em vez de aguardar a conclusão de um índice inteiro (que pode ser de vários documentos), ele aguardará apenas que os documentos que você especificar sejam indexados antes de executar a consulta. Isso às vezes é conhecido como "read your own write" (leia sua própria gravação) ou RYOW.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
private static void AtPlusExample() { Console.WriteLine("========= AtPlus"); // get the current count var result1 = _bucket.Query("SELECT COUNT(1) as airportCount FROM `travel-sample` WHERE type='airport'") .Rows.First(); Console.WriteLine($"Initial count: {result1.airportCount}"); // insert a new airport var doc = new Document { Id = "ScanConsistency::airport::" + _random.Next(10000), Content = new { type = "airport" } }; var insertResult = _bucket.Insert(doc); // get the count again var state = MutationState.From(insertResult.Document); var request = new QueryRequest("SELECT COUNT(1) as airportCount FROM `travel-sample` WHERE type='airport'"); var t = request.ConsistentWith(state); var result2 = _bucket.Query(t).Rows.First(); Console.WriteLine($"Count after insert with AtPlus: {result2.airportCount}"); } |
Com esse exemplo, a consulta N1QL aguardará apenas que o novo documento seja indexado. Ela não esperará por mais nada. Em um sistema de grande volume, isso pode proporcionar um bom equilíbrio entre maior desempenho e integridade dos resultados.
Observe que, no momento em que escrevemos esta postagem, você precisa se certificar de que definiu explicitamente UseEnhancedDurability como true ao configurar seu Configuração de cliente:
|
1 2 3 4 5 6 7 8 |
config.BucketConfigs = new Dictionary { { "travel-sample", new BucketConfiguration { UseEnhancedDurability = true } } }; |
Conclusão
Com o N1QL, há um espectro de velocidade e integridade. Com o Couchbase Server 4.5, agora você tem três opções. O NotBounded para velocidade bruta, o RequestPlus para integridade atualizada e o AtPlus fica no meio.
Por favor, deixe um comentário, me envie uma mensagem no Twitterou envie um e-mail para mim (matthew.groves AT couchbase DOT com).
