Ottoman es un Modelador de Datos de Objetos (ODM) para el SDK Node.js de Couchbase que proporciona esquema JSON y validación para NoSQL.
Por qué utilizar un ODM para Couchbase
Con Ottoman, declaras el esquema en tu código. Aunque Couchbase no tiene aplicación de esquema para tus documentos, la mayoría de las aplicaciones necesitan algún nivel de esquema incluso en NoSQL. Exploraremos cómo lograr esquema y validación en NoSQL usando Ottoman y Couchbase.
Es importante validar que los documentos cumplen ciertos requisitos antes de persistir. Aunque Ottoman crea una abstracción sobre el SDK de Couchbase, los beneficios superan a los inconvenientes. Un desarrollador crea mucha lógica alrededor de la creación y actualización de documentos, escribiendo pre/post ciclo de vida, trabajando con estructuras de datos y validación.
Bases de datos NoSQL y diseño de esquemas
Un ODM tiene un papel similar en NoSQL al que tiene en una base de datos relacional, pero con beneficios adicionales. Couchbase no impone la validación ya que es flexible en cuanto al esquema. Ottoman puede realizar ciertas comprobaciones a medida que tus aplicaciones persisten los datos. Podemos advertir y error contra tipos de datos no deseados y formatos para campos individuales mediante la definición de esquemas y modelos para varios tipos de documentos.
El código de su aplicación de servidor es donde un gran lugar para aplicar la lógica de negocio y validación. El objetivo de Ottoman es proporcionar una mejor experiencia de desarrollo junto con darle el control sobre el esquema y la validación mientras se utiliza Couchbase con Node. Queremos dar a los desarrolladores una herramienta fiable para construir sistemas que sean fáciles de diseñar, mantener y escalar.
Couchbase es una base de datos NoSQL
Couchbase Server es una base de datos de documentos sin esquema, categorizada como un almacén de datos NoSQL, no es la mejor descripción ya que Couchbase utiliza una variante de SQL para realizar consultas llamada N1QL. El hecho de que un esquema no se aplique estrictamente en bases de datos NoSQL como Couchbase no significa que no debas aplicarlo.
Con Couchbase, obtienes los beneficios del escalado a nivel empresarial, nodos en clúster y la capacidad de almacenar y recuperar datos en formato JSON.
Si estás familiarizado con Mongoose, un ODM para MongoDB, te sentirás bastante cómodo con Ottoman, ya que tienen muchas características que se superponen porque ambos están hechos para NodeJS y se utilizan para modelar y persistir datos en una base de datos de valores clave orientada a documentos JSON.
Documento frente a relacional Base de datos
A medida que exploramos vamos a explorar Couchbase y NoSQL Base de datos y diseño de esquemas, primero vamos a ver cómo una estructura de datos de documentos difiere de un diseño de base de datos relacional, en el ejemplo siguiente, verá una comparación lado a lado de los datos que representa un Hotel.
A la izquierda, tenemos un documento que puede almacenar números de teléfono en una matriz que nos permite almacenar varios números de teléfono de un mismo hotel. Para hacer esto en una base de datos relacional se necesitaría sin duda una nueva tabla y mantener una relación entre las dos utilizando claves primarias.
Si desea más información sobre el modelado de documentos, consulte los recursos que he reunido en una entrada de blog: Guía de modelado de datos JSON
En Ottoman, tenemos muchas construcciones para ayudar a definir esquemas y modelos a nivel de aplicación. Repasemos algunos de los términos más importantes que debes conocer en Ottoman.
Tipos
Como se ve en rosa en la imagen de arriba, las propiedades de documento con el tipo de nombre en Couchbase son casi equivalentes a las tablas en una base de datos relacional. Pueden ayudar a agrupar diferentes tipos de documentos JSON para propósitos de indexación. Cuando usamos índices secundarios en Couchbase, podemos indexar sobre cualquier clave en los documentos. Si sólo 100 de 10.000 documentos en tu base de datos usan un tipo de 'hotel' y normalmente quieres buscar hoteles basados en ciudad o estado, entonces podrías querer construir un Índice Secundario Compuesto que sólo necesite buscar a través de esos cien documentos donde ciudad o estado sean iguales a un cierto valor. Esto es mucho más eficaz que utilizar, por ejemplo, un índice primario.
Más información sobre la indexación en Couchbase!
Colecciones
De forma similar a los tipos en Couchbase 6.x (última versión principal de Couchbase en el momento de escribir esto) y no mostrados en la ilustración anterior, las colecciones se verán favorecidas en Couchbase 7 (ya en beta). En el caso de que utilizara colecciones, simplemente no tendría un tipo en cada documento y, en su lugar, asignar el documento a una propiedad hotel colección.
Documentos
Comparable a las filas de datos de una base de datos relacional. Los sistemas RDBMS tradicionales harán referencia a documentos relacionados de otras tablas, como se ve en la ilustración anterior. También puede hacer esto con un documento JSON, sin embargo; se sugiere incluir esa información como un documento incrustado cuando sea posible, como vemos con la propiedad número de teléfono del documento del hotel que es una matriz de números de teléfono. Aunque es un ejemplo muy simple de esto, piensa si tuvieras una propiedad de dirección que en sí misma fuera otro objeto JSON con muchas propiedades, podrías pensar que esto necesita tener su propio documento, pero anidar esa información en el documento padre en la mayoría de los casos está bien.
Campos
También conocidos como atributos, son similares a las columnas de una base de datos relacional y, con Ottoman, puede crear requisitos a nivel de campo como parte de su esquema.
Esquema
Aunque Couchbase no tiene esquema o es flexible en cuanto al esquema, podemos imponer una estructura a nivel de aplicación para nuestros documentos.
Modelo
Un método constructor que toma un esquema y crea una instancia de un documento equivalente a un único registro en una base de datos relacional. Esta instancia de documento puede ser construida y luego persistida a Couchbase por Ottoman utilizando el guardar() método.
Primeros pasos
Empecemos creando una aplicación de demostración que podamos utilizar para familiarizarnos con Ottoman como mapeador de documentos objeto.
Instalación de Couchbase
Antes de empezar, vamos a configurar Couchbase.
Puede elegir entre una de las siguientes opciones (para este artículo utilizamos la opción #1):
- Instalar Couchbase Server usando Docker
- Descargue Couchbase específico para su sistema operativo desde la página Sitio web de Couchbase
Vamos a navegar a través de algunos de los fundamentos de Ottoman mediante la implementación de un modelo que representa los datos para un ejemplo simplificado de aerolínea manteniendo la tradición con el conjunto de datos Travel-Sample de Couchbase.
Estoy usando Visual Studio Code, NodeJS v12.14, y NPM 6.14.8, así que necesitarás tener Node.js instalado en tu máquina. a continuación, crearemos un proyecto en blanco y empezaremos a escribir algo de código.
Inicializando nuestro proyecto con NPM
Creamos un directorio, inicializamos nuestro proyecto, instalamos Ottoman.js y abrimos en VS Code
|
1 |
mkdir intro-ottoman && cd $_ && npm init -y && npm i ottoman && touch createAirline.js && code . |
Abra el terminal en el editor de su elección, he añadido un comando al final que se abrirá en VS Code.
Conexión a Couchbase con Ottoman
Empezaremos a trabajar a partir del archivo ./createAirline.js bajo la raíz del proyecto y añade lo siguiente (basado en la configuración por defecto):
|
1 2 3 4 5 6 7 8 9 |
const { Ottoman, model, Schema } = require('ottoman') const ottoman = new Ottoman({collectionName: '_default'}); ottoman.connect({ connectionString: 'couchbase://localhost', bucketName: 'travel', username: 'Administrator', password: 'password' }); |
Conjuntamente esto importa el paquete ottoman y especifica la colección por defecto (estilo Couchbase Server 6.x)
Esquemas y modelos otomanos
Los modelos son constructores extravagantes compilados a partir de definiciones de esquemas. Una instancia de un modelo se llama documento. Los modelos en Ottoman te ayudan a crear, leer, actualizar y borrar fácilmente documentos en tu base de datos Couchbase.
La creación de un modelo otomano comprende algunas cosas:
Definición de un esquema documental
Un esquema define las propiedades de un documento a través de un objeto cuyo nombre clave corresponde al nombre de la propiedad en la colección.
|
1 2 3 4 5 |
const airlineSchema = new Schema({ callsign: String, country: String, name: String }) |
Aquí definimos tres propiedades (indicativo, país, nombre) dentro de nuestro esquema, todos de tipo Cuerda. Especificando un tipo para cada una de las propiedades de nuestro modelo, corresponde a un validador interno que se activará cuando el modelo se guarde en la base de datos y fallará si el tipo de datos del valor no es del tipo Cadena.
Se permiten los siguientes tipos de esquema:
Definición de un modelo de documento
Necesitamos llamar al constructor del modelo en la instancia otomana y pasarle el nombre de la colección y una referencia a la definición del esquema.
|
1 |
const Airline = ottoman.model('Airline', airlineSchema) |
Cuando llame al modelo() crea una copia del esquema y compila el modelo para usted.
Demos también la airlineSchema una propiedad de número de teléfono. Podemos añadir una función de validación que asegure que el valor es un número de teléfono válido. Sustituya la propiedad airlineSchema con estos tres bloques de código:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
const regx = /^(\([0-9]{3}\)|[0-9]{3}-)[0-9]{3}-[0-9]{4}$/ if(value && !value.match(regx)) { throw new Error(`Phone Number ${value} is not valid`) } } addValidators({ phone: phoneValidator }) const airlineSchema = new Schema({ callsign: String, country: String, name: String, phone: [{ type: String, validator: 'phone'}] }) |
En el ejemplo anterior, te muestro cómo crear un validador personalizado, que acaba de pasar a ser el uso de una expresión regular como el check-in de nuestro validador, acaba de entender que usted podría tener cualquier lógica dentro de uno de estos validadores y en un momento voy a mostrar un buen truco para reducir nuestro código hacia abajo teniendo en cuenta que estamos utilizando una expresión regular para nuestra coincidencia de los números de teléfono.
Definición de validadores
Validadores registrado con Ottoman (como hemos hecho aquí con el otomana.addValidators() ) será llamado una vez por cada valor que la propiedad de nuestro documento tenga en el array. Si la propiedad no tuviera un array y en su lugar tuviera un único valor String, el validador sólo se ejecutaría una vez. Por esta razón, imprimo el número de teléfono problemático si la validación falla.
Sin embargo, existe una forma más sencilla de validar cualquier valor de las propiedades del documento siempre que la comprobación que se realice utilice una expresión regular. La dirección ValidatorOption puede tomar un regexp y mensaje como argumento, por lo que podemos reducir nuestro código a:
|
1 2 3 4 5 6 7 |
const regx = /^(\([0-9]{3}\)|[0-9]{3}-)[0-9]{3}-[0-9]{4}$/ const airlineSchema = new Schema({ callsign: String, country: String, name: String, phone: [{type: String, validator: {regexp: regx, message: 'phone invalid'}}] }) |
Como puedes ver, podemos hacer todo lo que estábamos haciendo antes en línea al crear un nuevo Schema. Pero no dejes que esto te impida entender cómo crear un validador personalizado, a veces necesitamos lógica adicional y es por eso que el primer ejemplo sigue siendo algo que vale la pena conocer.
Básico Operaciones documentales en NoSQL
La mayoría de las operaciones básicas están cubiertas en nuestra documentación Ottoman V2, cubriremos algo de eso aquí, pero siéntase libre de sumergirse en nuestro Documentación de Ottoman V2 (alfa) e infórmenos si hay algo que no encuentra o no entiende.
Crear documentos
Teniendo en cuenta el código que ya repasamos anteriormente que crea un esquema, modelo y validadores. Guardar un modelo y persistirlo en la base de datos es bastante fácil. Vamos a crear un nuevo Línea aérea utilizando nuestro Esquema y luego guardarlo/persistirlo en la base de datos.
|
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 |
// Constructing our document const cbAirlines = new Airline({ callsign: 'CBA', country: 'United States', name: 'Couchbase Airlines', phone: ['321-321-3210', '321-123-1234'] }) // Persist the Couchbase Airlines document to Couchbase Server const saveDocument = async() => { try { const result = await cbAirlines.save() console.log(result) } catch (error) { throw error } } // Ensure that all indexes exist on the server ottoman.start() // Next, let's save our document and print a success message .then(async() => { saveDocument() .then(() => process.exit(0)) .catch((error) => console.log(error)) }) |
Tal vez se pregunte por qué no llamamos al guardarDocumento() por sí sola. En su lugar, la llamamos después de la función otomana.start() ha terminado. En iniciar es un atajo para ejecutar ensureCollections y ensureIndexes. Todo lo que tienes que saber por ahora es que este método se asegura de que los índices apropiados relacionados con Ottoman han sido creados en Couchbase y esto es importante para asegurar que podemos ejecutar cosas como el método encontrar() y utilizar herramientas como el Constructor de consultas a la que llegaremos al final del artículo.
En este punto, si ejecutáramos todo el código que hemos escrito usando Node, nuestro documento se guardaría en la base de datos:
|
1 |
node createAirline.js |
El resultado de esta operación:
|
1 2 3 4 5 6 7 8 |
_Model { callsign: 'CBA', country: 'United States', name: 'Couchbase Airlines', phone: [ '321-321-3210', '321-123-1234' ], id: '2384568f-f1e9-446e-97d1-cad697c40e76', _type: 'Airline' } |
Se devuelven los siguientes campos:
- Los campos indicativo, país y nombre son todos String, el valor más básico que podemos tener en un documento.
- El campo id es autogenerado por Couchbase y es una clave única. El valor ID es lo que usarás en cualquier caso para encontrar un documento con Ottoman en métodos como
findByIDoremoveByID - El campo teléfono está representado por una matriz y contiene números de teléfono válidos.
- En El campo _type puede ayudarnos a organizar nuestros documentos como lo hace una tabla en una base de datos relacional, en Couchbase 7, podemos utilizar colecciones y ámbitos.
Errores de validación
Si introducimos un número de teléfono no válido y ejecutamos nodo createAirline.js este archivo de nuevo, obtendríamos un mensaje de error:
|
1 |
ValidationError: Phone Number 321-321-32xx is not valid |
CONSEJO: Puede definir su conexión, esquema y modelos en archivos separados, exportarlos y utilizarlos en otros archivos. Cree un nuevo archivo llamado airline-schema-model.js y mover nuestro esquema y la definición del modelo a la misma:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
const { model, Schema } = require('ottoman') const regx = /^(\([0-9]{3}\)|[0-9]{3}-)[0-9]{3}-[0-9]{4}$/ const airlineSchema = new Schema({ callsign: String, country: String, name: String, phone: [{type: String, validator: {regexp: regx, message: 'phone invalid'}}] }) // Compile our model using our schema const Airline = model('Airline', airlineSchema) exports.airlineSchema = airlineSchema; exports.Airline = Airline; |
Ahora podemos crear algunos archivos nuevos, findAirline.js, updateAirline.jsy removeAirline.js y rellene cada archivo con lo siguiente:
|
1 2 3 4 5 6 7 8 9 10 |
const { Ottoman } = require('ottoman') const ottoman = new Ottoman({collectionName: '_default'}); ottoman.connect({ connectionString: 'couchbase://localhost', bucketName: 'travel', username: 'Administrator', password: 'password' }); const { Airline } = require('./airline-schema-and-model') |
Esto nos ayudará a separar parte de nuestro código para que no lo estemos repitiendo en cada archivo y a medida que repasamos cada una de las operaciones CRUD podemos simplemente añadir algo de código a cada archivo y nuestro esquema y modelo ya estarán importados.
Buscar documentos
Intentemos recuperar el registro que hemos guardado antes en la base de datos. La clase model expone varios métodos estáticos y de instancia para realizar operaciones en la base de datos. Ahora intentaremos encontrar el registro que creamos anteriormente utilizando el método find y pasándole el indicativo como término de búsqueda. Vamos a crear un nuevo fichero llamado findAirline.js y podemos añadir el siguiente código:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
// Find the Couchbase Airline document by Callsign from Couchbase Server const findDocument = async() => { try { Airline.find({ callsign: { $like: 'CBA' } }) .then((result) => console.log(result.rows)); } catch (error) { throw error } } ottoman.start() .then(async() => { findDocument() .then(() => process.exit(0)) .catch((error) => console.log(error)) }) |
Buscar resultado de documento:
|
1 2 3 4 5 6 7 8 9 |
Query Result: [ _Model { _type: 'Airline', callsign: 'CBA', country: 'United States', name: 'Couchbase Airlines', phone: ['321-321-3210','321-123-1234'], id: '971045ac-39d8-4e72-8c93-fdaac69aae31', } |
Actualizar documentos
Modifiquemos el registro anterior buscándolo por el indicativo, que podemos suponer que el indicativo será un campo único en nuestros datos, entonces podremos actualizar el documento todo en una sola operación.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
// Update the Couchbase Airline document by Callsign from Couchbase Server const findDocumentAndUpdate = async() => { const newDocument = { callsign: 'CBSA', country: 'United States', name: 'Couchbase Airways', phone: ['321-321-3210','321-123-1234'] } try { let result = await Airline.findOneAndUpdate( { callsign: { $like: 'CBA' } }, newDocument, { new: true } ) console.log(result) } catch (error) { throw error } } ottoman.start() .then(async() => { findDocumentAndUpdate() .then(() => process.exit(0)) .catch((error) => console.log(error)) }) |
Buscar documento y actualizar resultado:
|
1 2 3 4 5 6 7 8 |
_Model { _type: 'Airline', callsign: 'CBSA', country: 'United States', id: '971045ac-39d8-4e72-8c93-fdaac69aae31', name: 'Couchbase Airways', phone: [ '321-321-3210', '321-123-1234' ] } |
Eliminar documentos
Ottoman dispone de varios métodos para eliminar documentos: eliminar, removeById y removeMany. Teniendo en cuenta los numerosos ejemplos que hemos tenido hasta ahora, cada uno de ellos debería ser muy fácil de entender cómo se utiliza, por lo que aquí nos limitaremos a dar un ejemplo sencillo para mostrar cómo eliminar un documento que ya hemos encontrado utilizando la función encontrar() método.
|
1 2 3 4 5 6 7 8 9 |
// Remove the Couchbase Airline document by ID from Couchbase Server const removeDocument = async() => { try { await Airline.removeById('60e3f517-6a2a-41fe-be45-97081181d675') .then((result) => console.log(result)) } catch (error) { throw error } } |
Eliminar documento resultado es un simple valor casutilizado para rastrear cambios en documentos Couchbase.
|
1 |
{ cas: CbCas { '0': <Buffer 00 00 2e 30 62 db 6c 16> } } |
Middleware
Ya hemos visto nuestro middleware en acción, nuestro validador que creamos inicialmente puede aprovechar el middleware usando funciones que se ejecutan en etapas específicas de un pipeline pasando el control durante la ejecución de funciones asíncronas.
Ganchos disponibles
valideguardaractualizacióneliminar
Ejemplo de Middleware (también conocido como ganchos pre y post)
Vamos a intentar un ejemplo simplemente generando un log en la consola antes y después de la creación (guardado) de un documento, voy a crear un nuevo archivo llamado createWithHooks.js y la mayor parte del código te resultará familiar excepto que he añadido pre y post hooks que simplemente nos reportarán el nombre del documento pre-save y el id del documento post-save:
|
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 35 36 37 38 39 40 41 42 43 44 45 46 47 48 |
const { Ottoman } = require('ottoman') const ottoman = new Ottoman({collectionName: '_default'}); ottoman.connect({ connectionString: 'couchbase://localhost', bucketName: 'travel', username: 'Administrator', password: 'password' }); const { Airline, airlineSchema } = require('./airline-schema-and-model') // Plugins and Hooks are middleware, think lifecycle hooks! const pluginLog = (airlineSchema) => { airlineSchema.pre('save', (doc) => console.log(`Doc: ${doc.name} about to be saved`) ) airlineSchema.post('save', (doc) => console.log(`Doc: ${doc.id} has been saved`) ) }; // Our plugin must be registered before the model creation airlineSchema.plugin(pluginLog) // Constructing our document const cbAirlines = new Airline({ callsign: 'UNITED', country: 'United States', name: 'United Airlines', phone: ['321-321-3210', '321-123-1234'] }) const saveDocument = async() => { try { // pre and post hooks will run const result = await cbAirlines.save() console.log(result) } catch (error) { throw error } } ottoman.start() .then(async() => { saveDocument() .then(() => process.exit(0)) .catch((error) => console.log(error)) }) |
Guardar el resultado del documento:
|
1 2 3 4 5 6 7 8 9 10 |
Doc: United Airlines about to be saved Doc: 1316488a-98ba-4dbb-b0d7-ea6001a0bf57 has been saved _Model { callsign: 'UNITED', country: 'United States', name: 'United Airlines', phone: [ '321-321-3210', '321-123-1234' ], id: '1316488a-98ba-4dbb-b0d7-ea6001a0bf57', _type: 'Airline' } |
Tenemos nuestros mensajes antes y después de guardar. Con la validación, puedes asegurarte de que ciertos valores de las propiedades del documento cumplen tus criterios. Aprovechar el ciclo de vida cuando el documento se guarda, actualiza y elimina también nos ayudó a controlar el middleware otomano.
Construcción de consultas
Ottoman tiene una API muy rica que maneja muchas operaciones complejas soportadas por Couchbase y N1QL. Nuestro constructor de consultas crea tus sentencias N1QL por ti. Cuando usas Query Builder tienes tres opciones de que modo usar.
En los tres ejemplos siguientes, haré lo mismo utilizando cada uno de los tres modos diferentes de QueryBuilder (parámetros, funciones de acceso y modo mixto). Cada ejemplo lo hará:
- Seleccione
nombreypaísde Aerolíneas - Dónde está el
paísel valor es "Estados Unidos" - Y LIMITAR nuestros resultados al 10
Primero vamos a crear un nuevo archivo llamado: findWithQueryBuilder.jsy añada el siguiente código:
|
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 |
const { Ottoman, Query } = require('ottoman') const ottoman = new Ottoman({collectionName: '_default'}); ottoman.connect({ connectionString: 'couchbase://localhost', bucketName: 'travel', username: 'Administrator', password: 'password' }); /* Replace with QueryBuilder Example */ const executeQuery = async(query) => { try { const result = await ottoman.query(query) console.log('Query Result: ' , result) } catch (error) { throw error } } generateQuery() .then((query) => { executeQuery(query) .then(() => process.exit(0)) }) .catch((error) => console.log(error)) |
Este archivo tiene un comentario en el medio que dice: "Reemplazar con QueryBuilder Ejemplo". Podemos simplemente copiar cualquiera de los siguientes ejemplos de esta sección en esa zona del archivo.
Parámetros
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
const generateQuery = async() => { try { const params = { select : [ { $field: 'name' }, { $field: 'country'} ], where: { $and: [ { country: {$eq: 'United States'}}, { _type: {$eq: 'Airline'}} ] }, limit: 10 } const query = new Query(params, '`travel`').build() console.log('Query Generated: ', query) return query } catch (error) { throw error } } |
Funciones de acceso
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
const generateQuery = async() => { try { const query = new Query({}, '`travel`') .select([ { $field: 'name' }, { $field: 'country'} ]) .where({ $and: [ { country: {$eq: 'United States'}}, { _type: {$eq: 'Airline'}} ]}) .limit(10) .build() console.log('Query Generated: ', query) return query } catch (error) { throw error } } |
Modo mixto
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
const generateQuery = async() => { try { const where = { $and: [ { country: {$eq: 'United States'}}, { _type: {$eq: 'Airline'}} ] } // pass in our query as a condition expression const query = new Query({ where }, '`travel`') .select([ { $field: 'name' }, { $field: 'country' } ]) .limit(10) .build() console.log('Query Generated: ', query) return query } catch (error) { throw error } } |
Una vez creado un generarQuery() utilizando uno de los modos mixtos anteriores, deberá llamar de forma asíncrona a la función generateQuery y executeQuery y el código para que como he dicho funcionará con muchos sabores del código anterior:
Un resultado de cualquiera de los tres modos anteriores:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
Query Generated: SELECT name,country FROM default:`travel` WHERE (country="United States" AND _type="Airline") LIMIT 10 Query Result: { meta: { requestId: '1514fa20-755e-49b3-bbfa-4ed75a1a40ee', clientContextId: '0334862c79e727f8', status: 'success', signature: { country: 'json', name: 'json' }, profile: undefined, metrics: { elapsedTime: 6.219, executionTime: 5.9619, sortCount: undefined, resultCount: 2, resultSize: 106, mutationCount: undefined, errorCount: undefined, warningCount: undefined } }, rows: [ { country: 'United States', name: 'United Airlines' }, { country: 'United States', name: 'Jet Blue Airlines' } ] } |
Recursos
Conclusión
Hemos realizado una visita guiada por Ottoman para comprender muchos conceptos. Esquema, modelos, middleware, plugins, hooks y construcción de consultas.
Exploramos cómo conectar con Couchbase en Ottoman. Definimos esquemas y modelos. Tocamos varios fundamentos en el esquema y diseño de bases de datos NoSQL. Finalmente, recorrimos algunas de las operaciones CRUD más útiles. Todo un esfuerzo para ponerte al día en la creación, lectura, actualización y eliminación de documentos en Couchbase a través de Ottoman.
Opine y contribuya
Espero que este artículo haya desmitificado por qué y cómo usar Ottoman y ODM para Couchbase. Como se ha mostrado, puedes usar Ottoman para el diseño de esquemas de bases de datos NoSQL, validación y reducción de boiler-plate. La escritura de operaciones CRUD se simplifica y ayuda a un rápido desarrollo.
Si tienes alguna pregunta sobre Ottoman, quieres ayudar a contribuir a este proyecto de código abierto, o simplemente te gustaría saludar, mi nombre es Eric Bishard y soy el Developer Advocate aquí en Couchbase centrándome en la experiencia de los desarrolladores de Node.js y JavaScript, mi DM está siempre abierto en Twitter/@httpJunkie.
