Uno de los principales problemas de muchos técnicos es tratar de aplicar el patrón martillo de oro (Golden Hammer): para un martillo de oro todo son clavos. Aprenden una receta y quieren usar esta receta hasta las últimas consecuencias. Por ejemplo, aprenden a utilizar un gestor de bases de datos relacional de un vendedor importante y, como es lo que conocen, y de lo que se fían, pues a usarlo toda la vida.
En función del problema que queramos resolver hay soluciones mejores y peores. Hoy me ha picado la curiosidad de usar CouchDB en primera persona. Que conste que estoy explorando y compartiendo lo que voy viendo. Espero que os sea útil pero tendréis que ir a otros tutoriales si buscáis precisión.
Si vamos a la propia documentación de CouchDB podemos ver el teorema de CAP y que en un sistema distribuido hay que elegir dos de tres entre la consistencia, disponibilidad y tolerancia a la partición. https://es.wikipedia.org/wiki/Teorema_CAP
CouchDB proporciona una ventaja interesante (consecuencia de su posición en el teorema anterior) y es que permite que bases de datos se sincronicen de un modo automático y simple. Si tenemos un dispositivo móvil y se queda sin conexión, al recuperarse se resincroniza la información de la base de datos.
Para los que ya somos viejos en esto de la informática y hemos trabajado con otros sistemas NoSQL antes, como me tocó hace más de 17 años con Tamino, la base de datos http/XML de Software AG… pues parece prima hermana en muchas cosas.
CouchDB es un gestor de base de datos que trabaja con documentos JSON donde cada uno de ellos puede tener una estructura distinta autocontenida.
Pongamos un ejemplo sencillo: imagínate que queremos crear una base de datos de vehículos para gestionar las multas por aparcar en Madrid Centro :-))
Pues resulta que un vehículo es tanto una moto, como un coche, un tractor, autobús, furgoneta, ciclomotor o hasta un patinete.
Por tanto, en una estructura relacional tendríamos que crear una tabla común para los campos principales y tablas adicionales para otras estructuras.
En CouchDB, no es necesario.
Vamos a empezar con lo sencillo, instalando la base de datos y herramientas auxiliares y construyendo un pequeño ejemplo con los vehículos.
Estas son las características del equipo donde lo voy a instalar, estrenando portátil :-))
Descargamos de http://couchdb.apache.org/ en mi caso la versión macOS.
Una vez descargado lo arrancamos.
Al ejecutar nos aparece su interfaz gráfico de administración Fauxton
Nos vamos al icono de verificación y comprobamos que todo funciona
Seguimos las instrucciones http://docs.couchdb.org/en/stable/install/setup.html#install-setup. No estaría de más crear un usuario administrador y limitar el uso local. De momento nos lo saltamos para hacer pruebas en local.
Vamos a crear una base de datos.
Vamos a usar la aplicación Terminal y con el comando CURL atacar al puerto 5984.
Vamos desde la linea de comando a consultar la base de datos creada.
MacBook-Pro-de-Roberto:~ rcanales$ curl http://127.0.0.1:5984/vehiculosEl servidor nos retorna la respuesta.
{"db_name":"vehiculos","update_seq":"0-g1AAAABXeJzLYWBgYMpgTmEQTM4vTc5ISXLIyU9OzMnILy7JAUklMiTV____PyuRAY-iPBYgydAApP5D1GYBAJmvHGw","sizes":{"file":352,"external":0,"active":0},"purge_seq":0,"other":{"data_size":0},"doc_del_count":0,"doc_count":0,"disk_size":352,"disk_format_version":6,"data_size":0,"compact_running":false,"cluster":{"q":2,"n":1,"w":1,"r":1},"instance_start_time":"0"}
MacBook-Pro-de-Roberto:~ rcanales$ Vamos a crear un nuevo documento.. pinchando puntos suspensivos en nuestra base de datos de vehículos.
Creamos algunos documentos
{
"_id": "b9d281eb5e5e10d8321390e520005d21",
"tipo": "Motocicleta",
"matricula": "333YYZ",
"clasificacion": "B",
"color": "Negro",
"plazas": "2"
}
{
"_id": "b9d281eb5e5e10d8321390e520006193",
"tipo": "Tractor",
"matricula": "E99999",
"clasificacion": "E",
"color": "azul",
"plazas": "2",
"carga_maxima": "20T"
}
Es interesante localizar los ficheros de log por si hacemos algo mal: en mi caso. /Users/rcanales/Library/Logs/CouchDB2.log
Podemos ver los documentos creados.
Vuelco aquí unos pocos por si queréis jugar.
id"b9d281eb5e5e10d8321390e5200011f3"
{
"id": "b9d281eb5e5e10d8321390e5200011f3",
"key": "b9d281eb5e5e10d8321390e5200011f3",
"value": {
"rev": "1-f78aea7fff63cb29d1228a1bd7c561ca"
},
"doc": {
"_id": "b9d281eb5e5e10d8321390e5200011f3",
"_rev": "1-f78aea7fff63cb29d1228a1bd7c561ca",
"tipo": "Automovil",
"matricula": "1234YYY",
"clasificacion": "C",
"color": "blanco",
"plazas": "4",
"propietario": {
"titular": "Autentia SL",
"conductor": "Roberto Canales",
"uso": "personal"
}
}
}
id"b9d281eb5e5e10d8321390e520005d21"
{
"id": "b9d281eb5e5e10d8321390e520005d21",
"key": "b9d281eb5e5e10d8321390e520005d21",
"value": {
"rev": "1-f2536dbe849b74873ecbe2a1b91f6a88"
},
"doc": {
"_id": "b9d281eb5e5e10d8321390e520005d21",
"_rev": "1-f2536dbe849b74873ecbe2a1b91f6a88",
"tipo": "Motocicleta",
"matricula": "333YYZ",
"clasificacion": "B",
"color": "Negro",
"plazas": "2"
}
}
id"b9d281eb5e5e10d8321390e520006193"
{
"id": "b9d281eb5e5e10d8321390e520006193",
"key": "b9d281eb5e5e10d8321390e520006193",
"value": {
"rev": "1-a7ff9981fe95cbcec6b434e87a4b20c8"
},
"doc": {
"_id": "b9d281eb5e5e10d8321390e520006193",
"_rev": "1-a7ff9981fe95cbcec6b434e87a4b20c8",
"tipo": "Tractor",
"matricula": "E99999",
"clasificacion": "E",
"color": "azul",
"plazas": "2",
"carga_maxima": "20T"
}
}
Ahora vamos a hacer consultas. Podemos acceder a un documento directamente por URL.
Vamos a Crear una vista.
Los scripts se organizan en aplicaciones o grupos que he llamado listado1.
En este caso solo quiero consultar los vehículos que tienen carga máxima en los campos.
Creo una vista llamada listado-simple.
Hay que plantearse que la dinámica en las bases de datos NoSQL es un poquito distinta y utilizan el concepto de funciones map-reduce para recuperar información.
Creamos una función por la que pasan todos los documentos. En este caso voy a verificar que los vehículos tienen tipo y carga_maxima, es decir, si tienen los campos que me interesan y todos los demás son descartados.
Emit incluye en la lista de respuesta los elementos. La respuesta es un conjunto de claves valor (simple o compuestos). Esta clave luego se puede utilizar para filtrar.
Podemos editar en Fauxton directamente la función y ejecutarla. Podemos ver el resultado como tabla de documentos devueltos, metadatos (la respuesta) o el documento JSON.
Y obtenemos la respuesta
En la base de datos las vistas aparecen como un documento más. Esto nos viene muy bien porque luego vamos a hacer algo de trampa para crear otros elementos directamente.
Podemos pinchar en el documento y verlas todas las vistas juntas
Voy a crear otra vista.
La aplicación la llamo “vistas” a la vista “automoviles”
La función es:
function(doc) {
if(doc.matricula && doc.propietario) {
emit(doc.matricula,{"matricula": doc.matricula, "tipo": doc.tipo, "color": doc.color});
}
}
Si ejecutamos la consulta aparecen los documentos que tienen matricula y propietario.
El primer campo del emit, como hemos dicho, es la key (clave en el par clave-valor)
Podemos ver el aspecto en Fauxton
Si quiero filtrar por una matrícula concreta lo puedo hacer por key, podemos ver que solo aparece una. Para invocar una vista fijaros en el patrón
URL + base de datos + _design + nombre aplicación o conjunto + _view + tu vista? key (palabra clave y valor entrecomillado.
Os recomiendo que vayáis al manual para ver cómo crear las vistas equivalentes a distintos tipos de consultas clásicas en SQL.
CouchDB también nos permite crear respuestas automáticas de visualización creando vista tipo show.
Como hemos dicho que al fin y al cabo todo son documentos, lo edito directamente desde la lista de elementos de la base de datos de automóviles.
Lo he editado a mano dejándolo tal cual.
{
"_id": "_design/html",
"_rev": "9-1763a6f708e749b7acae0c59c07adac4",
"shows": {
"simple": "function(doc, req){ return 'La matricula es, ‘ + doc.matricula + ‘
‘; }» }, «language»: «javascript» }
Solamente tengo ahora que invocarlo
base de datos + _design + aplicación + vista + documento.
Bueno, con esto ya somos capaces de crear bases de datos, vistas, representaciones en HTML y editar en Fauxton los elementos. Ahora solo tenemos que configurar un formulario HTML para manipular los elementos desde nuestras páginas (y Java / JavaScript). Ya para el siguiente tutorial.
