New to Couchbase 4.5: AtPlus

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:

        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=&apos;airport&apos;")
                    .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=&apos;airport&apos;")
                    .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=&apos;airport&apos;")
                    .Rows.First();
            Console.WriteLine($"Count after waiting: {result3.airportCount}");
        }

privado estático vazio NotBoundedExample()

{

Console.WriteLine("========= NonBounded (padrão)");

// obter a contagem atual

var resultado1 =

_bucket.Consulta("SELECT COUNT(1) as airportCount FROM `travel-sample` WHERE type='airport'")

.Fileiras.Primeiro();

Console.WriteLine($"Initial count: {result1.airportCount}");

// inserir um novo aeroporto

var doc = novo Documento

{

Id = "ScanConsistency::airport::" + Aleatório.Próximo(10000),

Conteúdo = novo

{

tipo = "aeroporto"

}

};

_bucket.Inserir(doc);

// obter a contagem novamente

var resultado2 =

_bucket.Consulta("SELECT COUNT(1) as airportCount FROM `travel-sample` WHERE type='airport'")

.Fileiras.Primeiro();

Console.WriteLine($"Contagem após a inserção: {result2.airportCount}");

// espere alguns segundos e obtenha a contagem novamente

Console.Escrever("Aguardando por 5 segundos...");

Tópico.Dormir(5000);

var resultado3 =

_bucket.Consulta("SELECT COUNT(1) as airportCount FROM `travel-sample` WHERE type='airport'")

.Fileiras.Primeiro();

Console.WriteLine($"Contagem após a espera: {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.

        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=&apos;airport&apos;")
                    .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=&apos;airport&apos;");
            request.ScanConsistency(ScanConsistency.RequestPlus);
            var result2 = _bucket.Query(request).Rows.First();
            Console.WriteLine($"Count after insert with RequestPlus: {result2.airportCount}");
        }

privado estático vazio RequestPlusExample()

{

Console.WriteLine("========= RequestPlus");

// obter a contagem atual

var resultado1 =

_bucket.Consulta("SELECT COUNT(1) as airportCount FROM `travel-sample` WHERE type='airport'")

.Fileiras.Primeiro();

Console.WriteLine($"Initial count: {result1.airportCount}");

// inserir um novo aeroporto

var doc = novo Documento

{

Id = "ScanConsistency::airport::" + Aleatório.Próximo(10000),

Conteúdo = novo

{

tipo = "aeroporto"

}

};

_bucket.Inserir(doc);

// obter a contagem novamente

var solicitação =

Solicitação de consulta.Criar("SELECT COUNT(1) as airportCount FROM `travel-sample` WHERE type='airport'");

solicitação.Consistência de varredura(Consistência de varredura.RequestPlus);

var resultado2 = _bucket.Consulta(solicitação).Fileiras.Primeiro();

Console.WriteLine($"Contagem após a inserção com 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.

        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=&apos;airport&apos;")
                    .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=&apos;airport&apos;");
            var t = request.ConsistentWith(state);
            var result2 = _bucket.Query(t).Rows.First();
            Console.WriteLine($"Count after insert with AtPlus: {result2.airportCount}");
        }

privado estático vazio AtPlusExample()

{

Console.WriteLine("========= AtPlus");

// obter a contagem atual

var resultado1 = _bucket.Consulta("SELECT COUNT(1) as airportCount FROM `travel-sample` WHERE type='airport'")

.Fileiras.Primeiro();

Console.WriteLine($"Initial count: {result1.airportCount}");

// inserir um novo aeroporto

var doc = novo Documento

{

Id = "ScanConsistency::airport::" + Aleatório.Próximo(10000),

Conteúdo = novo

{

tipo = "aeroporto"

}

};

var insertResult = _bucket.Inserir(doc);

// obter a contagem novamente

var estado = Estado da mutação.De(insertResult.Documento);

var solicitação = novo Solicitação de consulta("SELECT COUNT(1) as airportCount FROM `travel-sample` WHERE type='airport'");

var t = solicitação.Consistente com(estado);

var resultado2 = _bucket.Consulta(t).Fileiras.Primeiro();

Console.WriteLine($"Contagem após a inserção com 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:

            config.BucketConfigs = new Dictionary {
                {
                    "travel-sample", new BucketConfiguration
                    {
                        UseEnhancedDurability = true
                    }
                }
            };

configuração.BaldeConfigs = novo Dicionário {

{

"amostra de viagem", novo BucketConfiguration

{

UseEnhancedDurability = verdadeiro

}

};

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.

Você pode Faça o download do código-fonte completo desta postagem do blog no Github.

Por favor, deixe um comentário, me envie uma mensagem no Twitterou envie um e-mail para mim (matthew.groves AT couchbase DOT com).

Matthew Groves

Platform

Self-Managed

Services

Capabilities

Why Couchbase?

Migrate to Capella

By Use Case

By Industry

By Application Need

Popular Docs

By Developer Role

Quickstart

Resource Center

About

Partnerships

Our Services

Partners: Register a Deal

Ready to register a deal with Couchbase?

Marriott

Todas as publicações

Novidade no Couchbase 4.5: AtPlus

Não limitado

RequestPlus

AtPlus (novo no Couchbase 4.5)

Conclusão

Autor

Postado por Matthew Groves

Deixar uma resposta Cancelar resposta