Using N1QL with Couchbase Eventing Functions.

Ahora bien, esto no es el fin. Ni siquiera es el principio del fin. Pero es, quizás, el final del principio. - Winston Churchill

La actualización de datos no suele ser el final, sino el progreso de un flujo de trabajo. El envío sigue al pedido; la actualización del inventario sigue al envío; el ajuste del crédito sigue a la devolución; es necesario actuar en el siguiente paso del proceso para que el flujo de trabajo siga avanzando. Los flujos de trabajo pueden ser sencillos, con pocos pasos, o complejos, con cientos de pasos. Gestión de procesos empresariales (BPM) es una industria en sí misma.

Presentación de Couchbase 5.5 Servicio nocturno. Los desarrolladores pueden escribir una función Javascript que se ejecute cuando se produzca un cambio en los datos. Nos referimos a las inserciones, actualizaciones, fusiones y eliminaciones como mutaciones. Múltiples casos de uso específicos se han documentado para desarrollar estos concurso funciones.

JSON modelo de datos de Couchbase procede de JavaScript. N1QL es SQL para JSON. Las funciones eventing están escritas en Javascript y tiene integrado N1QL. El uso de las funciones Eventing, escribir lógica de negocio de procedimiento con acceso instantáneo a los datos fácil.


// Simple counting function
// After every update to travel sample, keep track of the total number of documents of each type.
function OnUpdate(doc, meta) {
    try {
   
    // Issue SELECT statement to get the counts.
    var ginfo = SELECT type, COUNT(type) typecount FROM `travel-sample` WHERE `type` IS NOT MISSING GROUP BY type;

    // loop through the resultset
    for (var val of ginfo) {
      var ckey = "trcount" + val.type;  // Create the document key-string.
      var vtype = val.type; var vtc = val.typecount;  // get the type, count
      // do the update.
      UPDATE T1 USE KEYS[$ckey] SET  type =  $vtype, typecount =$vtc;
    }
  } catch(e) { log(e); }    
}

// Función de recuento simple

// Después de cada actualización de la muestra de viajes, lleve la cuenta del número total de documentos de cada tipo.

función OnUpdate(doc, meta) {

pruebe {

// Emita la sentencia SELECT para obtener los recuentos.

var ginfo = SELECCIONE tipo, CONTAR(tipo) typecount DESDE `viaje-muestra DONDE `tipo` IS NO FALTA GRUPO POR tipo;

// recorrer el conjunto de resultados

para (var val de ginfo) {

var ckey = "trcount" + val.tipo; // Crear la cadena de claves del documento.

var vtype = val.tipo; var vtc = val.typecount; // obtener el tipo, el recuento

// hacer la actualización.

ACTUALIZACIÓN T1 UTILICE TECLAS[$ckey] SET tipo = $vtype, typecount =$vtc;

}

} captura(e) { registro(e); }

}

Este es el ciclo de vida de las funciones desde la perspectiva del desarrollador. Para cada mutación, se puede definir cualquier número de estas funciones a ejecutar. Es responsabilidad del desarrollador dimensionar los tiempos de ejecución de las funciones, en función del número de mutaciones.

Este es el ciclo de vida de las funciones de Eventing:

Para cada inserción, actualización o supresión (directa o por expiración), puede ejecutar una o varias funciones javascript. Estas funciones pueden leer los nuevos datos y el tipo de acción y luego ejecutar la acción subsiguiente. Esta funcionalidad está bien descrita en los blogs y artículos de Couchbase.

Tipo de declaración	Función de eventos invocada
SELECCIONE	Ninguno
INSERTAR	OnUpdate(). La función se invoca una vez por documento insertado. La inserción simple inserta un único documento. Las inserciones pueden tener varios documentos utilizando varios documentos en la cláusula VALUES o pueden insertar varios documentos mediante la sentencia INSERT INTO...SELECT.
ACTUALIZACIÓN	Se invoca OnUpdate() una vez por documento actualizado, excepto cuando varias actualizaciones de un mismo documento se deduzcan en una sola actualización. La sentencia Update puede actualizar varios documentos.
UPSERT	OnUpdate(). El comportamiento es similar a INSERT.
BORRAR	OnDelete(). Se invoca una vez por cada documento eliminado.
FUSIONAR	OnUpdate() y/o OnDelete() en función de las acciones de inserción, actualización y eliminación.
CREAR ÍNDICE, ELIMINAR ÍNDICE, EXPLICAR, PREPARAR, CONCEDER, REVOCAR	No se invoca ninguna función de eventos.
EJECUTAR	Depende del tipo de sentencia ejecutada.

Estas funciones también pueden ejecutar sentencias N1QL. Resto del artículo se ve en todos los aspectos de N1QL ejecutado en Funciones Eventing.

Declaraciones N1QL en funciones Eventing.

Declaración	Casos de uso de las sentencias N1QL en las funciones de eventos
CREAR ÍNDICE	Dado que el esquema es flexible, podría inspeccionar los datos a menudo/periódicamente para detectar nuevos campos y luego crear índices sobre ellos.
BORRAR	Borrado en cascada.
DROP INDEX	Corolario del caso de uso CREAR ÍNDICE.
INFER	Introspección periódica del cubo para la estructura. A continuación, tomar medidas (validar, crear índice, actualizar el modelo de datos) si es necesario.
INSERTAR	Mantener datos referenciales (eventualmente). Actualizar otros documentos con referencias a estos datos. Por ejemplo, datos de un nuevo código postal, estado, etc. Copia de datos (total o parcialmente) en documentos secundarios/terciarios. Similar a la acción posterior a la activación.
FUSIONAR	Mantén sincronizados los datos secundarios.
SELECCIONE	Obtener datos, ejecutar informes periódicamente, etc. Compruebe diversos aspectos, como la calidad y la validez de los datos, Si conoce la clave del documento de destino, utilice las referencias directas incorporadas. Vea ejemplos en: https://docs.couchbase.com/server/5.5/eventing/eventing-examples.html
UPSERT	Mantener sincronizados los datos secundarios y terciarios. Similar a la acción posterior al disparo.
ACTUALIZACIÓN	Mantener sincronizados los datos secundarios y terciarios. Similar a la acción posterior al disparo.

Ejemplos: Probemos algunas funciones eventing con N1QL.


select meta().id, * from execute S1;

[
  {
    "S1": {
      "name": "Joe Smith",
      "zip": "94501"
    },
    "id": "Joe::94040"
  },
  {
    "S1": {
      "name": "John Smith",
      "zip": "94040"
    },
    "id": "John::94040"
  }
]



select meta().id, * from S2;


[
  {
    "S2": {
      "name": "Joe Smith",
      "zip": "94501"
    },
    "id": "Joe::94040"
  },
  {
    "S2": {
      "name": "John Smith",
      "zip": "94040"
    },
    "id": "John::94040"
  }
]


select meta().id, * from T1;
<No data>

seleccione meta().id, * de ejecutar S1;

[

{

"S1": {

"nombre": "Joe Smith",

"zip": "94501"

"id": "Joe::94040"

{

"S1": {

"nombre": "John Smith",

"zip": "94040"

"id": "Juan::94040"

}

]

seleccione meta().id, * de S2;

[

{

"S2": {

"nombre": "Joe Smith",

"zip": "94501"

"id": "Joe::94040"

{

"S2": {

"nombre": "John Smith",

"zip": "94040"

"id": "Juan::94040"

}

]

seleccione meta().id, * de T1;

N1QL simple en Funciones para registro y borrado en cascada.

Guarda cada documento eliminado en un cubo aparte.

function OnUpdate(doc, meta) {
}
function OnDelete(meta) {
  try {
      var myid = meta.id;
      //Insert into the bucket of 
      INSERT INTO T1 VALUES(UUID(), {"type" : "deleted", "docid":$myid});
      //Cascade delete
      DELETE FROM S2 USE KEYS [$myid];
  } catch(e) { log(e); }
}

After creating the function above, the application Runs the following:

DELETE FROM S1 WHERE zip = "94040";
// One document was deleted.

SELECT meta().id, * from S1;
// one document just got deleted. There should be only one document remaining.
[
  {
    "S1": {
      "name": "Joe Smith",
      "zip": "94501"
    },
    "id": "Joe::94040"
  }
]



SELECT meta().id, * from T1;
// We should see a log of the deleted
[
  {
    "T1": {
      "docid": "John::94040",
      "type": "deleted"
    },
    "id": "2dc9b33d-3cd4-422e-af9c-b0c664c4660f"
  }
]

SELECT meta().id, * FROM S2;
// We should only see one document due to the effect of cascade delete from the the function
[
  {
    "S2": {
      "name": "Joe Smith",
      "zip": "94501"
    },
    "id": "Joe::94040"
  }
]

función OnUpdate(doc, meta) {

}

función OnDelete(meta) {

pruebe {

var miid = meta.id;

//Insertar en el cubo de

INSERTAR EN T1 VALORES(UUID(), {"tipo" : "borrado", "docid":$miid});

//Eliminación en cascada

BORRAR DESDE S2 UTILICE TECLAS [$miid];

} captura(e) { registro(e); }

}

En crear el función sobre, el aplicación Ejecuta el siguiente:

BORRAR DESDE S1 DONDE zip = "94040";

// Se ha eliminado un documento.

SELECCIONE meta().id, * de S1;

// un documento acaba de ser borrado. Sólo debería quedar un documento.

[

{

"S1": {

"nombre": "Joe Smith",

"zip": "94501"

"id": "Joe::94040"

}

]

SELECCIONE meta().id, * de T1;

// Deberíamos ver un registro de los borrados

[

{

"T1": {

"docid": "Juan::94040",

"tipo": "borrado"

"id": "2dc9b33d-3cd4-422e-af9c-b0c664c4660f"

}

]

SELECCIONE meta().id, * DESDE S2;

// Sólo deberíamos ver un documento debido al efecto de borrado en cascada de la función

[

{

"S2": {

"nombre": "Joe Smith",

"zip": "94501"

"id": "Joe::94040"

}

]

OnUpdate() para mantener la información agregada lista periódicamente.


function OnUpdate(doc, meta) {
    try {
        var stattime = SELECT lastupdate FROM T1 USE KEYS ["trstattime"];
        for (var t of stattime) {
            var lt = t.lastupdate;
            var d = new Date();
            var n = d.getTime();
            // Every 10 minutes or more
            if ((n - lt)  > (1000 * 60 * 10)) {  
                UPDATE  T1 USE KEYS["trstattime"]  SET lastupdate = NOW_MILLIS() ;
                var ginfo = SELECT type, count(type) typecount FROM `travel-sample` WHERE `type` IS NOT MISSING GROUP BY type;
                for (var val of ginfo) {
                   var ckey = "trcount::" + val.type;
                   var vtype = val.type; var vtc = val.typecount;
                   UPDATE T1 USE KEYS[$ckey] SET  type =  $vtype, typecount = $vtc;
                }
        }
     }
    } catch(e) { log(e); }    
}

función OnUpdate(doc, meta) {

pruebe {

var stattime = SELECCIONE últimaactualización DESDE T1 UTILICE TECLAS ["trstattime"];

para (var t de stattime) {

var lt = t.últimaactualización;

var d = nuevo Fecha();

var n = d.getTime();

// Cada 10 minutos o más

si ((n - lt) > (1000 * 60 * 10)) {

ACTUALIZACIÓN T1 UTILICE TECLAS["trstattime"] SET últimaactualización = AHORA_MILLIS() ;

var ginfo = SELECCIONE tipo, cuente(tipo) typecount DESDE `viaje-muestra DONDE `tipo` IS NO FALTA GRUPO POR tipo;

para (var val de ginfo) {

var ckey = "trcount::" + val.tipo;

var vtype = val.tipo; var vtc = val.typecount;

ACTUALIZACIÓN T1 UTILICE TECLAS[$ckey] SET tipo = $vtype, typecount = $vtc;

}

} captura(e) { registro(e); }

}

Referencias:

Documentación de Couchbase: https://docs.couchbase.com/server/5.5/eventing/eventing-overview.html
Blogs de Couchbase sobre eventing: https://www.couchbase.com/blog/tag/eventing/

Keshav Murthy

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

Uso de N1QL con funciones de eventos de Couchbase.

Autor

Publicado por Keshav Murthy

Dejar una respuesta Cancelar respuesta