New to Couchbase 4.5: AtPlus

Lo que estoy aprendiendo Couchbase es que, aunque su objetivo es proporcionar valores predeterminados razonables, también ofrece opciones para hacer concesiones. La compensación en la que me voy a centrar en esta entrada de blog es Scan Consistency para consultas N1QL.

Couchbase 4.5 introduce un nuevo Opción de coherencia de exploración: AtPlus. Esto se une a las opciones existentes para hacer un total de tres:

NotBounded (por defecto)
AtPlus (nuevo en Couchbase Server 4.5)
SolicitarPlus

Esta entrada del blog va a revisar NotBounded y RequestPlus, así como introducir AtPlus. También voy a proporcionar un ejemplo de código que se puede utilizar para probar los tres a ti mismo.

No limitado

Este es el comportamiento por defecto.

Una consulta N1QL que utiliza Consistencia de Escaneo "No Limitada" significa que no esperará a que ningún índice termine de actualizarse antes de ejecutar la consulta y devolver los resultados. Supongamos que tiene los documentos A,B,C en un bucket. En el momento de la consulta, sólo A y B están indexados. Con Not Bounded, sólo se devolverán los documentos A y B.

Dado que la consulta no espera a ser indexada, ésta es la mejor opción en cuanto a rendimiento. El documento C aparecerá una vez indexado. Esto no debería llevar mucho tiempo, pero si acaba de crear C, por ejemplo, e inmediatamente después realiza una consulta para obtener una lista completa de documentos, es posible que C no aparezca. Para hacer una demostración con el viaje-muestra cubo:

        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 void NotBoundedExample()

{

Consola.WriteLine("========= NonBounded (por defecto)");

// obtener el recuento actual

var resultado1 =

_bucket.Consulta("SELECT COUNT(1) as airportCount FROM `viajes-muestra` WHERE type='aeropuerto'")

.Filas.En primer lugar();

Consola.WriteLine($"Recuento inicial: {result1.airportCount}");

// insertar un nuevo aeropuerto

var doc = nuevo Documento

{

Id = "ScanConsistency::aeropuerto::" + _random.Siguiente(10000),

Contenido = nuevo

{

tipo = "aeropuerto"

}

};

_bucket.Inserte(doc);

// obtener de nuevo el recuento

var resultado2 =

_bucket.Consulta("SELECT COUNT(1) as airportCount FROM `viajes-muestra` WHERE type='aeropuerto'")

.Filas.En primer lugar();

Consola.WriteLine($"Recuento después de insertar: {result2.airportCount}");

// espera unos segundos y vuelve a obtener el recuento

Consola.Escriba a("Esperando 5 segundos...");

Hilo.Dormir(5000);

var resultado3 =

_bucket.Consulta("SELECT COUNT(1) as airportCount FROM `viajes-muestra` WHERE type='aeropuerto'")

.Filas.En primer lugar();

Consola.WriteLine($"Recuento después de esperar: {result3.airportCount}");

}

Lo que yo esperaría ver al ejecutar este código es:

Recuento inicial: N
Recuento después de la inserción: N (todavía)
En espera
Cuenta después de esperar: N+1

He fijado el tiempo de espera en 5 segundos, lo que probablemente sea excesivo. Utilizo Thread.Sleep sólo con fines demostrativos, pero obviamente es una táctica torpe para una aplicación real. Esto nos lleva a RequestPlus.

SolicitarPlus

Esta opción de consistencia de escaneo proporciona casi lo contrario de No limitado. Esperará hasta que se procesen todos los cambios de documentos y actualizaciones de índices (hasta que se ejecute la consulta) antes de ejecutar la consulta.

He aquí un ejemplo simplificado de secuencia de eventos al utilizar RequestPlus

Se crea el documento C
Se ejecuta la consulta N1QL para obtener todos los documentos (A,B,C existen todos en el bucket)
La consulta N1QL se pone en espera porque al menos un documento necesita ser indexado (documento C).
El proceso de indexación ha finalizado. El documento C ya está indexado.
La consulta N1QL se ejecuta y devuelve 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 void RequestPlusExample()

{

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

// obtener el recuento actual

var resultado1 =

_bucket.Consulta("SELECT COUNT(1) as airportCount FROM `viajes-muestra` WHERE type='aeropuerto'")

.Filas.En primer lugar();

Consola.WriteLine($"Recuento inicial: {result1.airportCount}");

// insertar un nuevo aeropuerto

var doc = nuevo Documento

{

Id = "ScanConsistency::aeropuerto::" + _random.Siguiente(10000),

Contenido = nuevo

{

tipo = "aeropuerto"

}

};

_bucket.Inserte(doc);

// obtener de nuevo el recuento

var solicitar =

Solicitud de consulta.Cree("SELECT COUNT(1) as airportCount FROM `viajes-muestra` WHERE type='aeropuerto'");

solicitar.Consistencia de escaneado(Consistencia de escaneado.SolicitarPlus);

var resultado2 = _bucket.Consulta(solicitar).Filas.En primer lugar();

Consola.WriteLine($"Recuento después de insertar con RequestPlus: {result2.airportCount}");

}

Esto nos proporciona exhaustividad en los resultados de la consulta, a costa del rendimiento. En algunos casos, no tiene sentido esperar a que todo a indexar. Y eso nos lleva a AtPlus.

AtPlus (nuevo en Couchbase 4.5)

Esta opción de coherencia de escaneado ofrece un término medio entre RequestPlus y Not Bounded. También es una opción nueva opción de escaneo de coherencia para Couchbase 4.5.

Con AtPlus, tendrás que hacer un poco más de trabajo en tu código, pero a cambio obtendrás un mejor rendimiento que usando RequestPlus. En lugar de esperar a que se complete un índice completo (que podría ser de múltiples documentos), sólo esperará a que se indexen los documentos que especifiques antes de ejecutar la consulta. Esto se conoce a veces como "read your own write" o 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 void AtPlusEjemplo()

{

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

// obtener el recuento actual

var resultado1 = _bucket.Consulta("SELECT COUNT(1) as airportCount FROM `viajes-muestra` WHERE type='aeropuerto'")

.Filas.En primer lugar();

Consola.WriteLine($"Recuento inicial: {result1.airportCount}");

// insertar un nuevo aeropuerto

var doc = nuevo Documento

{

Id = "ScanConsistency::aeropuerto::" + _random.Siguiente(10000),

Contenido = nuevo

{

tipo = "aeropuerto"

}

};

var insertarResultado = _bucket.Inserte(doc);

// obtener de nuevo el recuento

var estado = MutationState.En(insertarResultado.Documento);

var solicitar = nuevo Solicitud de consulta("SELECT COUNT(1) as airportCount FROM `viajes-muestra` WHERE type='aeropuerto'");

var t = solicitar.CoherenteCon(estado);

var resultado2 = _bucket.Consulta(t).Filas.En primer lugar();

Consola.WriteLine($"Recuento después de insertar con AtPlus: {result2.airportCount}");

}

Con este ejemplo, la consulta N1QL esperará únicamente a que se indexe el nuevo documento. No esperará nada más. En un sistema de gran volumen, esto podría proporcionar un buen equilibrio entre un mayor rendimiento y la exhaustividad de los resultados.

Tenga en cuenta que en el momento de escribir este post, tendrá que asegurarse de que establece explícitamente UseEnhancedDurability a verdadero al configurar su ClientConfiguration:

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

config.CuboConfigs = nuevo Diccionario {

{

"viaje-muestra", nuevo BucketConfiguration

{

UseEnhancedDurability = verdadero

}

};

Conclusión

Con N1QL, hay un espectro de velocidad e integridad. Con Couchbase Server 4.5, ahora tienes tres opciones. NotBounded para la velocidad bruta, RequestPlus para la exhaustividad actual, y AtPlus se sitúa en medio.

Puede descargue el código fuente completo de esta entrada del blog en Github.

Por favor, deje un comentario, ping me on Twittero envíeme un correo electrónico (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

Todos los mensajes

Nuevo en Couchbase 4.5: AtPlus

No limitado

SolicitarPlus

AtPlus (nuevo en Couchbase 4.5)

Conclusión

Autor

Publicado por Matthew Groves

Dejar una respuesta Cancelar respuesta