NoSQL: la siguiente generación de Base de Datos

NoSQL: la siguiente generación
de bases de datos
19 Abril de 2012, 9:00-14:30
Miramon Enpresa Digitala. Paseo Mikeletegi 56, 1. 20009 San Sebastián

Dr. Diego Lz. de Ipiña Glz. de Artaza
DeustoTech-INTERNET2, DeustoTech – Deusto Institute of Technology, Universidad de Deusto
dipina@deusto.es
http://paginaspersonales.deusto.es/dipina
http://www.morelab.deusto.es

1

Agenda
1. Introducción a las bases de datos NoSQL (60’)
– Concepto y campos relacionados
– Principales características
– Arquitectura de las bases de datos NoSQL
– Taxonomía de soluciones NoSQL
– Empresas que usan bases de datos NoSQL
2. Ejemplo de almacén de datos clave-valor NoSQL: Apache Cassandra
(90’)
– Introducción: características y arquitectura
– Instalación sobre diferentes sistemas operativos
– Programación de Cassandra desde Java y Python
– La API Thrift y otras características avanzadas
– Desarrollo de una aplicación avanzada en Cassandra
Descanso (20’)
2

Agenda
3. Ejemplo de almacén de base de datos orientada a
documentos: CouchDB (90’)
– Introducción: características (vistas, modelado sin esquemas) y
arquitectura
– Instalación sobre diferentes sistemas operativos
– La API HTTP de CouchDB HTTP
– Programación de aplicaciones desde Python y Java
– Desarrollo de una aplicación avanzada con CouchApp
4. Conclusiones (40’)
– Comparativa entre las diferentes soluciones de NoSQL
– Otras alternativas destacables: MongoDB, HBase
– Aplicabilidad a mi empresa

3

Ejemplos de este Curso
• Los ejemplos asociados al curso, junto al
software necesario para su ejecución, puede
descargarse de:
– http://dl.dropbox.com/u/2763621/CursoNoSQL/N
oSQL-cd.rar

4

Introducción a NoSQL
• NoSQL – es un término utilizado para describir un
subconjunto de bases de datos que difiere en varios
modos de bases de datos tradicionales (RDBMS).
– No tienen schemas, no permiten JOINs, no intentan
garantizar ACID y escalan horizontalmente
• El término fue acuñado en 1998 por Carlo Strozzi y
resucitado en 2009 por Eric Evans
– El propio Evans sugiere mejor referirse a esta familia de
BBDD de nueva generación como “Big Data”

5

• NoSQL – "not only SQL” – es una categoría general
de sistemas de gestión de bases de datos que difiere
de modelo relacionales clásicos (RDBMS) en
diferente modos:
– Estos data stores no requieren esquemas de información
fijas
– Evitan las operaciones JOIN y escalan horizontalmente
• De hecho, tanto las bases de datos NoSQL como las
relacionales son tipos de Almacenamiento
Estructurado.
6

• La principal diferencia radica en cómo guardan los datos (por
ejemplo, almacenamiento de un recibo):
– En una RDBMS tendríamos que partir la información en
diferentes tablas y luego usar un lenguaje de programación en la
parte servidora para transformar estos datos en objetos de la
vida real.
– En NoSQL, simplemente guardas el recibo:
• NoSQL es libre de schemas, tú no diseñas tus tablas y
su estructura por adelantado
• ¡¡¡NoSQL no es la panacea!!!
– Si tus datos son relacionales, quedarte con tu RDBMS sería la opción
correcta
7

El teorema CAP
• Teorema de Brewer: “es imposible para un sistema computacional
distribuido ofrecer simultáneamente las siguientes tres garantías”:
– Consistencia – todos los nodos ven los mismos datos al mismo tiempo
– Disponibilidad (Availability) – garantiza que cada petición recibe una
respuesta acerca de si tuvo éxito o no
– Tolerancia a la partición (Partition) – el sistema continua funcionando a pesar
de la pérdida de mensajes
• Equivalente a:
– “You can have it good, you can have it fast, you can have it cheap: pick two.”

8

RDBMS vs. NoSQL
• Las bases de datos relacionales tradicionales nos permiten definir la estructura de
un esquema que demanda reglas rígidas y garantizan ACID:
– Atomicity
– Consistency
– Isolation
– Durability
• Las aplicaciones web modernas presentan desafíos muy distintos a las que
presentan los sistemas empresariales tradicionales (e.j. sistemas bancarios):
– Datos a escala web
– Alta frecuencia de lecturas y escrituras
– Cambios de esquema de datos frecuentes
– Las aplicaciones sociales (no bancarias) no necesitan el mismo nivel de ACID
• Algunas de las opciones de NoSQL actualmente disponibles son: Cassandra,
MongoDB, Jackrabbit , CouchDB, BigTable y Dynamo

9

¿Por qué necesitamos NoSQL?
• Las BBDD relacionales ofrecen bajo rendimiento ante ciertas aplicaciones
intensivas de datos:
– Indexación de un gran número de documentos
– Servir páginas en sites de mucho tráfico
– Envío de datos de streaming
• Las RDBMS están optimizadas para pequeñas pero frecuentes
transacciones de lectura/escritura o largas transacciones con pocos acceso
de escritura.
• NoSQL puede dar servicio a grandes cargas de lectura/escritura:
– Digg mantiene 3 TB de green badges (marcadores que indican las historias
votadas por otros en una red social)
– Facebook que tiene que realizar búsqueda en bandejas de mensajes de más
de 50 TB

10

Arquitectura de las BBDD NoSQL
• A menudo ofrecen sólo garantías de consistencia
débiles, como por ejemplo eventual consistency, o
transacciones restringidas a elementos de datos
simples
• Emplean una arquitectura distribuida, donde los
datos se guardan de modo redundante en distintos
servidores, a menudo usando tablas hash
distribuidas
• Suelen ofrecer estructuras de datos sencillas como
arrays asociativos o almacenes de pares clave-valor
11

¿Qué tipo de BBDD elijo?
• Algunas respuestas pueden encontrarse en:
– 35+ Use Cases For Choosing Your Next NoSQL
Database
• http://highscalability.com/blog/2011/6/20/35-use-
cases-for-choosing-your-next-nosql-database.html
– Five Reasons to Use NoSQL
• http://facility9.com/2010/09/five-reasons-to-use-
nosql/
• Las más populares son: Cassandra, CouchDB,
MongoDB, Riak, Neo4j
12

¿Quién usa NoSQL?
• No lo usan para todo, sólo para algunas partes
de sus sistemas empresariales:
– Ubuntu DesktopCouch (CouchDB)
– Adobe y Mozilla (Hbase)
– Twitter
(http://www.readwriteweb.com/cloud/2011/01/h
ow-twitter-uses-nosql.php)

13

Taxonomía de soluciones NoSQL
• Los principales tipos de BBDD de acuerdo con
su implementación son los siguientes:
– Almacenes de documentos
– Almacenes de Clave-Valor
– Grafos

14

Base de Datos orientada a
Documentos
• Una base de datos orientada a documentos es un programa
diseñado para almacenar, recuperar y gestionar información
semi-estructurada orientada a documentos:
– Un documento encapsula información en un formato estándar (XML,
YAML, JSON o BSON):
• Los documentos en una BBDD orientada a documentos son similares a
registros pero no requieren un esquema estándar con la mismas
secciones, huecos, partes, claves y similar
• Los documentos suelen ser direccionables por una clave que los
representa unívocamente
• Además de la búsqueda por clave de documento, estas BBDD suelen
ofrecer una API o lenguaje de consultas que permite recuperar
documentos en base a sus contenidos

15

Características BBDD
orientadas a Documentos
• La precursora fue Lotus Notes
• Modelo de datos: colecciones de documentos que
contienen colecciones de claves-valor
• Ejemplos: CouchDB, MongoDB
• Buenas en:
– Modelado de datos natural
– Amigables al programador
– Desarrollo rápido
– Orientas a la web: CRUD

16

Características BBDD
orientadas a Clave-Valor
• Su precursor fue Google BigTable
• Modelo de datos: familia de columnas, esto es, un
modelo tabular donde cada fila puede tener una
configuración diferente de columnas
• Ejemplos: HBase, Hypertable, Cassandra,Riak
• Buenas en:
– Gestión de tamaño
– Cargas de escrituras masivas orientas al stream
– Alta disponibilidad
– MapReduce
17

Distributed Hash Table (DHT)
• Un distributed hash table (DHT) es una clase de sistema distribuido que permite
un servicio de lookup similar a un Hash Table
– Almacenan pares clave valor
– Cada nodo puede obtener eficientemente el valor asociado a una clave
– La responsabilidad de mantener los mapeos entre claves y valores está distribuida entre
los nodos
– Escalan a grandes números de nodos y gestionan la llegada continua de nodos, salidas y
fallos

18

Apache Cassandra
• Es un almacén altamente escalable, eventualmente
consistente y distribuido de estructuras clave-valor.
– Iniciado por Facebook
– Código abierto
– Proyecto apache
• Licencia: Apache License 2.0
– Escrito en Java
– Multiplataforma
– Versión actual: 1.0.9
– Web: http://cassandra.apache.org/
• Documentación: http://www.datastax.com/docs/1.0/index

19

¿Quién usa Apache Cassandra?
• Algunos usuarios famosos de Cassandra son:
– Digg
– Facebook
– Twitter
– Rackspace
– SimpleGEO
–…

20

Ventajas de Cassandra para
desarrolladores Web
• Cassandra está desarrollada para ser un servidor distribuido, pero puede también
ejecutarse como un nodo simple:
– Escalabilidad horizontal (añade nuevo hardware cuando sea preciso)
– Rápidas respuestas aunque la demanda crezca
– Elevadas velocidades de escritura para gestionar volúmenes de datos incrementales
– Almacenamiento distribuido
– Capacidad de cambiar la estructura de datos cuando los usuarios demandan más
funcionalidad
– Una API sencilla y limpia para tu lenguaje de programación favorito
– Detección automática de fallos
– No hay un punto de fallo único (cada nodo conoce de los otros)
– Descentralizada
– Tolerante a fallos
– Permite el uso de Hadoop para implementar Map Reduce
– Hinted hand off

21

Desventajas de Cassandra
• Hay algunas desventajas que un sistema de
almacenamiento tan escalable ofrece en
contrapartida:
– No hay joins (a cambio de más velocidad)
– No permite ordenar resultados en tiempo de
consulta
– No tiene SQL
• Pero desde la versión 0.8 tenemos CQL

22

Instalación de Cassandra
• Documentación en:
– Cassandra Wiki: GettingStarted,
http://wiki.apache.org/cassandra/GettingStarted
• Requisitos:
– Java 1.6 en adelante
• Las últimas versiones estables disponibles en:
– http://cassandra.apache.org/download/

23

Instalación de Cassandra
• Disponible desde: http://cassandra.apache.org/download/
– Descargar apache-cassandra-1.0.9-bin.tar.gz o similar
• Descomprimir en tu sistema con Winrar o usando gzip en
Linux
• Asociar a la variable de entorno PATH la localización de la
carpeta bin dentro de Apache Cassandra:
– En Windows podría quedar en:
C:ProgrammingJavaapache-cassandra-1.0.3bin

24

Ejecutando un nodo de
Cassandra
• Arrancar Apache Cassandra, ejecutando:
– cassandra –f
• -f le dice a Cassandra que se ejecute en foreground para ver así los logs
del sistema
• Tenemos un cluster con un solo nodo ejecutándose en el
puerto 9160
• La configuración de este nodo la podemos encontrar en:
conf/cassandra.yaml
• Ejecutar el cliente de consola para asegurarnos que todo está
bien:
– cassandra-cli

25

Comandos CLI Básicos
• help; – también se puede user ‘?’, sirve
para pedir ayuda
• Para conectarte a un servidor, hacer:
– connect localhost/9160;
• Alternativamente: cassandra-cli
localhost/9160
– show cluster name;
– show keyspaces;
– show API version;
26

Comandos CLI Básicos
• Vamos a crear un KeySpace, algo así como una base de datos relacional:
– Define un conjunto de familias de columnas
• Una familia de columnas es algo así como una tabla
drop keyspace MyKeySpace;
create keyspace MyKeySpace;
use MyKeySpace;
create column family User;
describe MyKeySpace;
assume User keys as Ascii;
assume User comparator as Ascii;
set User['dipina']['lname']='Lopez-de-Ipina';
set User['dipina']['fname']='Diego';
set User['dipina']['email']='dipina@deusto.es';
count User['dipina'];
get User['dipina'];
del User['dipina']['email'];
del User['dipina'];
get User['dipina'];
27

Ring, clúster y el protocolo
Gossip
• Cassandra usa un protocolo Gossip para permitir
comunicación dentro de un ring, de tal modo que cada nodo
sabe de otros nodos
– Permite soportar descentralización y tolerancia a la partición
• Cassandra está diseñada para ser distribuida en varias
máquinas que aparecen como una simple máquina a los ojos
de los clientes
– La estructura más externa de Cassandra es el cluster o ring
• Un nodo tiene una réplica para diferentes rangos de datos, si algo va mal
una réplica puede responder
– El parámetro replication_factor en la creación de un KeySpace indica
cuántas máquinas en el clúster recibirán copias de los mismos datos.

28

Ejecutando un Clúster
• Hay que repetir el paso anterior varias veces, PERO…
– Necesitamos indicar qué nodo va a funcionar como Seed, dado que los
nodos en Cassandra se comunican usando un protocolo Gossip
• La idea es permitir que los nodos en un cluster se descubran unos a otros
– Además deberemos indicar la interfaz IP para escuchar para Gossip y
Thrift
• Documentación en:
– http://crlog.info/2011/07/09/setting-up-a-multi-node-cassandra-
cluster-on-a-single-windows-machine/
– http://www.datastax.com/docs/0.7/getting_started/configuring

29

Ejecutando un Clúster
• Vamos a realizar un ejemplo con 4 nodos en Windows. Los pasos a seguir serán:
1. Abrir el fichero hosts en C:WindowsSystem32driversetc
2. Añadir el siguiente contenido, para crear 4 nodos locales:
#cassandra nodes
127.0.0.1 node1.cassandra
3. Descomprime apache-cassandra-1.0.5-bin.tar.gz en 4 carpetas, por ejemplo:
%HOME%apache-cassandra-1.0.51 a %HOME%apache-cassandra-1.0.54
4. Editar cada confcassandra.yaml con lo siguiente:
• Propiedad cluster_name=“PruebaCluster”
• Asegúrate que auto_bootstrap: false en node1 y node2
• Configura los dos seed nodes con la línea: seeds: node1.cassandra, node2.cassandra
• Modifica los directorios de datos: data_file_directories, commitlog_directory y
saved_caches_directory
– Por ejemplo, commitlog_directory: /var/lib/cassandra/1/commitlog
• Modifica las variables:
– listen_address: node1.cassandra
– rpc_address: node1.cassandra
5. Modicar el número de puerto en cassandra.bat de JMX: -
Dcom.sun.management.jmxremote.port=7199
6. Ejecutar el siguiente comando para ver los nodos en el clúster:
• 30
nodetool -h 127.0.0.1 -p 7199 ring

Teorema CAP en Cassandra
• Las bases de datos derivadas de Amazon Dynamo
incluyen Cassandra, Voldemort, CouchDB y Riak
– Centradas más en disponibilidad y tolerancia a fallos
• Permiten Consistencia Eventual
– Donde “eventual” significa milisegundos
– Por tanto Cassandra es AP:
• “To primarily support Availability and Partition Tolerance, your
system may return inaccurate data, but the system will always be
available, even in the face of network partitioning”

31

Modelo de Datos en Cassandra
• Está basado en un modelo clave-valor
• Extiende el modelo clave-valor con dos niveles
de anidamiento
• Su modelo de datos representa un mapa de 4
o 5 dimensiones.
– El modo de referirse a un registro de datos es:
• Un keyspace, una column family, una key, una super
column opcional, y una column.
– Al final siempre tenemos un valor único que es la columna.

32

Modelo de Datos en Cassandra
• Diseñado para datos distribuidos de modo escalable  sacrifica ACID por ventajas
en rendimiento, disponibilidad y gestión operacional
• Los modelos que se crean son desnormalizados:
– Se suele crear una column family por cada consulta (query) a realizar
– Varias filas en un column family suelen dar respuesta a una consulta
• Los conceptos básicos son:
– Clúster: son las máquinas que componen una instancia de Cassandra
• Pueden contener varios Keyspaces
– Keyspace: espacio de nombres para un conjunto de ColumFamily, asociado a una
aplicación
• Suele vincularse con una BBDD en el modelo relacional
– ColumFamily: contienen varias columnas
• Suelen vincularse con una tabla en el modelo relacional
– SuperColumn: columnas que ellas mismas tienen sub-columnas
– Column: compuestas de un nombre, valor y timestamp

33

Column
• Una columna es un par nombre-valor que también contiene
un timestamp
– Los nombres y columnas son arrays de bytes
– El timestamp registra la última vez que una columna es accedida
– Unidad atómica
• name:value:timestamp
• Email:dipina@deusto.es:123456789
• Ejemplo en JSON:
{
"name": "Email",
"value": "dipina@deusto.es",
"timestamp”: 123456789
}
34

Super-columnas
• Una supercolumna es un array asociativo
(mapa) de columnas ordenadas por nombre

35

Column Family
• Es un contenedor de columnas
– Análogo al concepto de tabla en RDBMS
• Contiene una lista ordenada de columnas
– Cuando se crea de manera configurativa una familia de columnas se indica
cómo se ordenarán las columnas de cada fila (cogiendo el nombre)
• ASCII, UTF-8, Long, UUID
• Cada familia de columnas se guarda en un fichero, y el fichero está
ordenado por clave de fila
• Una familia de columnas tiene un …
conjunto de filas con un conjunto de …
columnas similar pero no idéntico
• Pueden ser de tipo SUPER o STANDARD

36

Column Family
• Ejemplo en JSON:
{
"mccv":{
"Users":{
"emailAddress":{"name":"emailAddress", "value":"foo@bar.com"},
"webSite":{"name":"webSite", "value":"http://bar.com"}
},
"Stats":{
"visits":{"name":"visits", "value":"243"}
}
},
"user2":{
"Users":{
"emailAddress":{"name":"emailAddress",
"value":"user2@bar.com"},
"twitter":{"name":"twitter", "value":"user2"}
}
}
}
37

Familia de super-columnas
• Una familia de super-columnas es un
contenedor de super-columnas ordenadas por
sus nombres, a su vez estas super-columnas
aparecen ordenadas por las claves de fila
(row_key)

38

Familia de super-columnas

39

Familias de Columnas vs. Familia
de Super-Columnas
• Una fila en una familia de columnas normal es un mapa de
nombres de columna ordenadas a valores de columna
– “The address of a value in a regular column family is a row key
pointing to a column name pointing to a value”

• Una fila en una familia de super-columnas es un mapa
ordenado de nombres de super-columnas a mapas de
nombres de columnas a valores de columnas
– “The address of a value in a column family of type “super” is a row
key pointing to a column name pointing to a subcolumn name pointing
to a value”

40

KeySpaces
• Un espacio de claves o KeySpace es un esquema de
alto nivel que contiene familias de columnas.
– Supercolumn Family “Estado de Usuario”

– Column Family “Entradas en Twitter: tweets”:

41

Resumen Modelo de Datos

42

Clúster
• Los datos en Cassandra se guardan en un
Clúster o Ring donde se asignan datos a los
nodos dentro de un ring
– Un nodo tiene réplicas para diferentes rangos de
datos
– Si un nodo se cae su réplica puede responder
– Un protocolo P2P hace que los datos se repliquen
entre nodos acorde con un
replication_factor

43

Configuración de un Keyspace
• Los atributos básicos que puedes asociar a un
keyspace son:
– Replication factor: cuánto quieres pagar en rendimiento a
favor de consistencia
– Replica placement strategy: indica cómo se colocan las
réplicas en el anillo: SimpleStrategy,
OldNetworkTopologyStrategy y NetworkTopologyStrategy
• Revisar: http://answers.oreilly.com/topic/2408-replica-placement-
strategies-when-using-cassandra/
– Column families: al menos una por Keyspace, es un
contenedor de filas, que contienen columnas

44

Otros aspectos importantes
• Cassandra ofrece soporte para particionado distribuido de
datos
– RandomPartitioner te da buen balanceo de carga
– OrderPreservingPartitionioner te permite ejecutar consultas de
rangos, pero exige más trabajo eligiendo node tokens
• Más info en: http://abel-perez.com/cassandra-partitioner-order-
preserving-partit
• Cassandra tiene consistencia reconfigurable
– http://www.datastax.com/docs/0.8/dml/data_consistency
• Con Cassandra tienes que pensar en las consultas que quieres
ejecutar y luego realizar el modelo en torno a ellas

45

Diferencias entre un RDBMS y
Cassandra
• No hay lenguaje de consulta, tiene una API accesible a través de Thrift
– Verdad a medias: si existe desde la versión 0.8 CQL
• No hay integridad referencial, no hay joins, se puede emular almacenando claves a otras filas
en un column family
• Índices secundarios en una tabla dan lugar a nuevos column families que mapean un campo a
la clave de la primera column family
– Verdad a medias: desde Cassandra 0.7 se pueden crear índices secundarios:
http://www.datastax.com/dev/blog/whats-new-cassandra-07-secondary-indexes
• Ordenar es una decisión de diseño, las definiciones de familias de columnas incluyen un
elemento CompareWith
– BytesType, UTF8Type, AsciiType, LongType, LexicalUUIDType, TimeUUIDType
• Las filas son agrupadas y ordenadas (distribuidas en el cluster) por el Partitioner
– RandomPartitioner, OrderPreservingPartitioner,
CollatingOrderPreservingPartitioner
• Cassandra tiene mejor rendimiento con datos desnormalizados
• Modelas las consultas y luego defines la estructura de datos a su alrededor

46

RDBS vs. KeySpace

47

Soporte Multi-lenguaje de
Cassandra
• Cassandra utiliza la librería Thrift (http://thrift.apache.org/)
para proveer una API independiente del lenguaje de
programación
– Thrift API 1.0: http://wiki.apache.org/cassandra/API
– Ejemplo en: http://wiki.apache.org/cassandra/ClientExamples
• Thrift soporta un gran número de lenguajes incluyendo: C++,
Java, Python, PHP, Ruby, Erlang, Perl, Haskell, C#, Cocoa,
JavaScript, Node.js, Smalltalk, y Ocaml
• Hay muchas librerías clientes disponibles:
– Pycassa para Python: http://pycassa.github.com/pycassa/index.html
– Hector para Java: https://github.com/rantav/hector

48

Avro vs. Thrift
• Avro remplazará Thrift como cliente RPC para interaccionar con Cassandra.
– Avro es un subproyecto de Apache Hadoop project
– Proporciona funcionalidad similar a Thrift pero es una librería de serialización
dinámica que no requiere generación de código estática como Thrift
– Thrift fue creado por Facebook y luego donado a Apache, pero apenas ha
recibido soporte últimamente.
• El servidor de Cassandra será portado de
de org.apache.cassandra.thrift.CassandraServer a org
.apache.cassandra.avro.CassandraServer
– Todavía no hecho
• Más información sobre Avro en: http://avro.apache.org.

49

Mi primera aplicación con
Cassandra
• Relational vs.
– Cassandra Model

50

Cassandra vs. RDBMS
• Un RDBS es un modelo basado en el dominio
– ¿qué respuestas tienes?
• Cassandra tiene un modelo orientado a
consultas
– ¿qué preguntas tienes?

51

Pycassa: un cliente Python
para Apache Cassandra
• Instalación:
– Dependencias:
• Instalar Python 2.7 o en adelante
• Instalar setuptools
– Descarga el ficero .zip de https://github.com/pycassa/pycassa
– Descomprímelo en tu disco duro
– Instala pip siguiendo las instrucciones en:
• http://www.pip-installer.org/en/latest/installing.html
– Ejecuta python setup.py install
• Más info en:
– http://pycassa.github.com/pycassa/tutorial.html#connecting-to-
cassandra

52

Interactuando con Cassandra
desde Python: pycassa
• Comprobar que la librería funciona haciendo desde
Python:
import pycassa
• Asegúrate que el KeySpace1 existe en Cassandra
Ejecuta: cassandra-cli –h localhost -f
CreateKeySpace1.txt
• Conéctate a Cassandra:
from pycassa.pool import ConnectionPool
pool = ConnectionPool('Keyspace1')

53

• Recupera una ColumnFamily:
from pycassa.pool import ConnectionPool
from pycassa.columnfamily import ColumnFamily
pool = ConnectionPool('Keyspace1')
col_fam = pycassa.ColumnFamily(pool, 'Standard1')
• Insertando datos:
col_fam.insert('row_key', {'col_name':
'col_val'})
col_fam.insert('row_key2', {'col_name':'col_val',
'col_name2':'col_val2'})
col_fam.batch_insert({'row1': {'name1': 'val1',
'name2': 'val2'}, 'row2': {'foo': 'bar'}})

54

• Pare recuperar las columnas de una fila:
– col_fam.get('row_key')
• Si no queremos recuperar todas las columnas en una fila:
– col_fam.get('row_key', columns=['col_name',
'col_name2'])
• Podemos también recuperar un rango de columnas en una fila
o en orden decreciente un número máximo de columnas:
for i in range(1, 10):
... col_fam.insert('row_key', {str(i): 'val'})
col_fam.get('row_key', column_start='5',
column_finish='7')
col_fam.get('row_key', column_reversed=True,
column_count=3)
55

• Para recuperar múltiples filas usamos:
col_fam.multiget(['row1', 'row2'])
• También podemos recuperar rangos de filas:
result = col_fam.get_range(start='row_key5',
finish='row_key7')
• Para conocer el número de columnas en una fila:
col_fam.get_count('row_key')
col_fam.get_count('row_key', columns=['foo', 'bar'])
col_fam.get_count('row_key', column_start='foo')
• Para contabilizar las filas que cumplen ciertas restricciones:
col_fam.multiget_count(['fib0', 'fib1', 'fib2', 'fib3',
'fib4'])
• Tutorial de pycassa en: http://pycassa.github.com/pycassa/tutorial.html#

56

Twissandra
• Download de: https://github.com/twissandra/twissandra
• Instalar Django:
– Bajar la última versión de: https://www.djangoproject.com/download/
– Descomprimir el archivo descargado
– Ejecutar: python setup.py install
• Instalar Twissandra:
– Crear el schema
• cd twissandra
• python manage.py sync_cassandra
– Arrancar el webserver
• python manage.py runserver
• Los dos ficheros más importantes a revisar son:
– Twissandra/tweets/management/commands/
sync_cassandra.py
• Muestra cómo crear el schema de datos de Twissandra
– twissandra/cass.py
• Muestra cómo hacer CRUD sobre ese schema
57

Modelo de Datos de Twissandra
• Usuarios:
User = {
'hermes': {
'password': '****',
(other properties),
},
}
• Amigos y seguidores:
Friends = {
'hermes': {
# friend id: timestamp of when the friendship was added
'larry': '1267413962580791',
'curly': '1267413990076949',
'moe' : '1267414008133277',
},
}

Followers = {
'hermes': {
# friend id: timestamp of when the followership was added
'larry': '1267413962580791',
'curly': '1267413990076949',
'moe' : '1267414008133277',
}, 58
}

Modelo de Datos de Twissandra
• Tweets:
Tweet = {
'7561a442-24e2-11df-8924-001ff3591711': {
'username': 'hermes',
'body': 'Trying out Twissandra. This is awesome!',
},
}
• Timeline y UserLine:
Timeline = {
'hermes': {
# timestamp of tweet: tweet id
1267414247561777: '7561a442-24e2-11df-8924-001ff3591711',
1267414277402340: 'f0c8d718-24e2-11df-8924-001ff3591711',
1267414305866969: 'f9e6d804-24e2-11df-8924-001ff3591711',
1267414319522925: '02ccb5ec-24e3-11df-8924-001ff3591711',
},
}

Userline = {
'hermes': {
# timestamp of tweet: tweet id
1267414247561777: '7561a442-24e2-11df-8924-001ff3591711',
1267414277402340: 'f0c8d718-24e2-11df-8924-001ff3591711',
1267414305866969: 'f9e6d804-24e2-11df-8924-001ff3591711',
1267414319522925: '02ccb5ec-24e3-11df-8924-001ff3591711',
},
}
59

Cassandra Query Language (CQL)
• Cassandra ha sido accedido principalmente mediante Thrift – una API RPC
que proporciona un denominador común a clientes para lenguajes
específicos
• Pero:
– Thrift es de demasiado bajo nivel para ser usado de modo productivo o dar
soporte a nuevas funcionalidades como los índices secundarios en 0.7 o los
contadores distribuidos en 0.8
• CQL da respuesta a ésto pasando todos los detalles de implementación
complejos al servidor
– Los clientes sólo tienen que saber cómo interpretar objetos en un “resultset”
• Documentación:
• http://www.datastax.com/dev/blog/what%E2%80%99s-new-in-cassandra-0-8-
part-1-cql-the-cassandra-query-language
• http://www.datastax.com/docs/0.8/dml/using_cql#use-cql

60

Acceso a CQL
• Los desarrolladores pueden usar CQL desde Python o línea de
comandos
• Existen drivers en diferentes lenguajes de programación
• Nosotros vamos a practicar con comandos CQL a través del
cliente de línea de comandos cqlsh
• Desde Apache Cassandra 1.0.5, el cliente cqlsh está
instalado en $CASSANDRA_HOME/bin/cqlsh para
instalaciones tarball o /usr/bin/cqlsh para instalaciones
de paquetes Linux
• Ejemplo programático en:
– http://crlog.info/2011/06/13/cql-creating-a-simple-keyspace/

61

Un poco de CQL
• Ejemplos tomados de: http://www.datastax.com/dev/blog/what%E2%80%99s-new-in-cassandra-0-8-part-1-cql-the-cassandra-query-
language
cqlsh> CREATE KEYSPACE test with strategy_class = 'SimpleStrategy' and strategy_options:replication_factor=1;
cqlsh> USE test;

cqlsh> CREATE COLUMNFAMILY users (
... key varchar PRIMARY KEY,
... full_name varchar,
... birth_date int,
... state varchar
... );

cqlsh> CREATE INDEX ON users (birth_date);
cqlsh> CREATE INDEX ON users (state);

cqlsh> INSERT INTO users (key, full_name, birth_date, state) VALUES ('bsanderson', 'Brandon Sanderson', 1975,
'UT');
cqlsh> INSERT INTO users (key, full_name, birth_date, state) VALUES ('prothfuss', 'Patrick Rothfuss', 1973,
'WI');
cqlsh> INSERT INTO users (key, full_name, birth_date, state) VALUES ('htayler', 'Howard Tayler', 1968, 'UT');

cqlsh> SELECT key, state FROM users;
key | state |
bsanderson | UT |
prothfuss | WI |
htayler | UT |

cqlsh> SELECT * FROM users WHERE state='UT' AND birth_date > 1970;
KEY | birth_date | full_name | state |
bsanderson | 1975 | Brandon Sanderson | UT |

62

Un poco de CQL
• Más ejemplos en:
http://www.datastax.com/docs/1.0/dml/using_cql
cqlsh> CREATE KEYSPACE twissandra1 WITH
strategy_class = 'NetworkTopologyStrategy' AND
strategy_options:DC1 = 3;
cqlsh> USE twissandra;
cqlsh> CREATE COLUMNFAMILY users (
KEY varchar PRIMARY KEY,
password varchar,
gender varchar,
session_token varchar,
state varchar,
birth_year bigint);
63

Hector
• Una API de alto nivel en Java para Cassandra
– Incluye características empresariales: connection pooling, monitoring, etc.
• Documentación:
– Tutorial:
• https://github.com/rantav/hector/wiki/User-Guide
• https://github.com/zznate/cassandra-tutorial
– Getting started guide:
• https://github.com/rantav/hector/wiki/Getting-started-%285-minutes%29
– Ejemplos:
• https://github.com/zznate/hector-examples
• https://github.com/zznate/cassandra-tutorial
• https://github.com/riptano/twissjava
– Inicializar BBDD con create-twissjava-db.txt
– Ejecutar: mvn jetty:run
– Ir a: http://localhost:8888/
– mvn clean

64

CouchDB
• CouchDB es una base de datos open source
orientada a documentos, accesible mediante una API
RESTful que hace uso extensivo de JavaScript Object
Notation (JSON)
– "Couch" es el acrónimo de"Cluster Of Unreliable
Commodity Hardware"
• Su misión es ser muy escalable, con alta disponibilidad y robustez,
incluso cuando se ejecuta en hardware convencional
– Creada como “database of the Web”
“Django may be built for the Web, but CouchDB is built of the Web. I’ve never
seen software that so completely embraces the philosophies behind HTTP.
CouchDB makes Django look old-school in the same way that Django makes
ASP look outdated.”
—Jacob Kaplan-Moss, Django developer
65

Características de CouchDB
• CouchDB es una base de datos orientada a documentos JSON escrita en
Erlang.
– Parte de la generación de bases de datos NoSQL
– Es un proyecto open source de la fundación Apache
• Es altamente concurrente, diseñada para ser replicada horizontalmente, a
través de varios dispositivos y tolerante a fallos.
• Permite a las aplicaciones guardar documentos JSON a través de una
interfaz RESTful
• Utiliza map/reduce para indexar y consultar la base de datos
• Permite escribir una aplicación cliente que habla directamente vía HTTP
con CouchDB sin necesidad de una capa servidora intermedia
• Guarda datos en local en la propia máquina cliente para reducir latencia
– Gestiona la replicación a la nube por ti

66

CouchDB: BBDD orientada a documentos
• Una BBDD document-oriented está compuesta de una serie de
documentos
– Son libres de esquema; no existe un esquema definido a priori, antes de usar
la BBDD
• Si un documento necesita un nuevo campo, puedes incluirlo, sin afectar a otros
documentos en la BBDD
• CouchDB no tiene una funcionalidad de auto-increment o secuencia
– Asigna un Universally Unique Identifier (UUID) a cada documento, haciendo
casi imposible que otra base de datos seleccione el mismo identificador
• No soporta JOINs como las bases de datos relacionales
– Una característica denominada vista permite crear relaciones arbitrarias entre
documentos que no son definidas en las propias bases de datos.
• CouchDB ofrece una alternativa a todos aquellos proyectos donde un
modelo orientado a documentos encaja mejor que una base de datos
relacional: wikis, blogs y sistemas de gestión documental
67

Ventajas de CouchDB
• Documentos JSON – todo lo que se guarda en CouchDB son simplemente
documentos JSON.
• Interfaz RESTful – desde la creación a la replicación a la inserción de
datos, toda la gestión de datos en CouchDB puede ser realizada vía HTTP.
• Replicación N-Master – puedes hacer uso de un número ilimitado de
‘masters’, dando lugar a topologías de replicación muy interesantes.
• Escrita para ejecutarse offline – CouchDB puede replicarse en dispositivos
(e.j. teléfonos Android) que pueden quedarse sin conexión y gestionar
sincronización de datos cuando el dispositivo está online de nuevo
• Filtros de replicado – puedes filtrar de modo preciso los datos que quieres
replicar a distintos nodos.
– http://wiki.apache.org/couchdb/Replication#Filtered_Replication

68

¿Quién usa CouchDB?
• Un largo listado de software y websites que
hacen uso de CouchDB puede encontrarse en:
– http://wiki.apache.org/CouchDB/CouchDB_in_the
_wild?action=show&redirect=InTheWild

69

Conceptos clave en CouchDB:
Documentos
• Una base de datos en CouchDB es una
colección de documentos, donde cada uno
está identificado por un ID y contiene un
conjunto de campos nombrados:
– Los campos pueden ser strings, números, fechas o
incluso listas ordenadas y diccionarios.
– Ejemplos de documentos serían:
"Subject": "I like Plankton“,
"Tags": ["plankton", "baseball",
"decisions"]
70

Documentos
• Las BBDD CouchDB guardan documentos nombrados de modo unívoco y
proporcionan una API RESTful JSON que permite a las aplicaciones leer y modificar
estos documentos
– Cada documento puede tener campos no definidos en otros documentos:
• Los documentos no están asociados a un esquema de bases de datos estricto
• Cada documento contiene metadatos (datos sobre datos) como el identificador
unívoco del documento (id) y su número de revisión (rev)
• Los campos de un documento pueden ser de varios tipos como strings, números,
booleanos, colecciones, etc.
• Cuando se hacen cambios sobre un documento CouchDB se crea una nueva
versión del documento, denominado revisión
– Se mantiene un historial de modificaciones gestionado automáticamente por la BBDD
• CouchDB no dispone de mecanismos de bloqueo (locking) ante escrituras

71

Vistas
• Son el mecanismo para añadir estructura a datos semi-
estructurados
• El modelo de vistas en CouchDB usa JavaScript para
describirlas
• Las vistas son el método para agregar y realizar informes
sobre los documentos de un repositorio, siendo creados en
demanda para agregar y agregar documentos.
• Las vistas se construyen dinámicamente y no afectan el
documento subyacente, puedes tener tantas
representaciones de vistas de los mismos datos como gustes.

72

Vistas
• CouchDB es desestructurado en naturaleza, adolece de un esquema estricto pero
provee beneficios en términos de flexibilidad y escalabilidad, explotar sus datos en
aplicaciones reales a veces puede hacerse complicado
– Los datos se guardan en un espacio de almacenamiento plano, algo así como un
repositorio de datos desnormalizados.
– Proporciona un modelo de vistas para añadir estructura a los datos de modo que pueda
agregarse para añadir significado útil
• Las vistas se crean en demanda y son utilizadas para agregar, enlazar y reportar
sobre documentos en la base de datos
– Se definen en documentos de diseño y pueden ser replicadas a través de varias
instancias
– Estos documentos de diseño contienen funciones JavaScript que pueden ejecutar
consultas mediante el concepto de MapReduce.
• La función Map de la vista recibe un documento como argumento y realiza una
serie de cálculos para determinar qué datos deberían ser disponibles en la vista
• Si la vista tiene una función Reduce, es usada para agregar los resultados. A partir
de un conjunto de pares clave/valor devuelve un sólo valor.
73

Ejemplo de Vista en CouchDB
map: function(doc) {
if (doc._attachments) {
emit("with attachment", 1);
}
else {
emit("without attachment", 1);
}
}

reduce: function(keys, values) {
return sum(values);
}

74

Sin esquema
• CouchDB está diseñado para almacenar y reportar sobre
grandes volúmenes de datos orientados a documentos semi-
estructurados.
• Con CouchDB, no se impone ningún esquema, nuevos tipos
de documentos con distintos campos y significados se pueden
unir a los existentes.
• El motor de vistas, apoyado en JavaScript, está diseñado para
facilitar la gestión de nuevos tipos de documentos y variados
pero similares documentos.

75

Conceptos clave: Distribuida
• CouchDB es un sistema distribuido de base de datos basado
en nodos
– Un número variable de nodos CouchDB (servidores y clientes offline)
pueden tener “copias de réplicas” independientes de la misma BBDD,
donde las aplicaciones pueden tener interactividad completa con la
BBDD (consultar, añadir, editar y borrar)
• Cuando vuelven a estar online o de modo planificado, los cambios de las
bases de datos son replicados bidireccionalmente.
• CouchDB tiene gestión de conflictos incorporada de serie,
haciendo que el proceso de replicación sea incremental y
rápido, copiando sólo documentos y campos individuales
modificados desde la última replicación.
– Utiliza Multi-Version Concurrency Control (MVCC)
76

Gestión de Conflictos MVCC
• Los documentos en CouchDB son versionados, de modo
similar a como se realiza en sistemas de control de versiones
como Subversion.
• Si cambias un valor de un documento, realmente creas una
nueva versión del mismo que coexiste con la versión antigua
• Las peticiones se ejecutan en paralelo haciendo que los
servidores permitan una alta concurrencia
– Una petición de lectura verá siempre la versión más reciente de la
BBDD

77

Teorema CAP en CouchDB
• El teorema CAP dice que en BBDD distribuidas sólo dos
de los siguientes propiedades pueden cumplirse:
– Consistency
• Todas las bases de datos cliente ven los mismos datos,
incluso cuando se producen actualizaciones concurrentes.
– Availability
• Todos los clientes pueden acceder a los datos.
– Partition tolerance
• La base de datos puede partirse a múltiples servidores
• CouchDB sacrifica consistencia inmediata a cambio de
obtener un mayor rendimiento a través de distribución
de la información

78

Detalles técnicos
• Un servidor CouchDB gestiona bases de datos bajo un
nombre, que almacenan documentos:
– Cada documento tiene un nombre único en la BBDD y CouchDB
proporciona una API HTTP RESTful para leer y modificar (añadir, editar
y borrar) documentos de la BBDD.
– Los documentos son la unidad de datos primaria en CouchDB y
consisten de un número variable de campos y adjuntos
– Las modificaciones sobre documentos (añadir, editar, borrar) son del
todo o de nada, o se modifican completamente o fallan
completamente.
– El modelo de modificación de documentos de CouchDB es optimista y
no hace uso de locks.
– Más detalles genéricos en:
http://CouchDB.apache.org/docs/overview.html
79

Modelo de Vistas
• Para añadir estructura a datos no estructurados o semi-
estructurados, CouchDB incorpora el modelo de vistas
– Se crean dinámicamente y no afectan al documento subyacente
– Se definen dentro de documentos de diseño
– Se replican a otras instancias de la base de datos como si fueran
documentos convencionales
• En CouchDB sólo se replican datos, aunque esos datos a menudo (código
JavaScript) puede corresponder a aplicaciones.
• Para garantizar un alto rendimiento, el motor de vistas
mantiene índices de sus vistas e incrementalmente las
actualiza para reflejar los cambios en la base de datos.

80

Map/Reduce en CouchDB
• Usar Map/Reduce tiene ventajas sobre
consultas SQL porque pueden ser distribuidas
entre varios nodos, algo que no puede
hacerse con RDBMS.
• Las bases de datos NoSQL utilizan map/reduce
para consultar e indexar la BBDD
– map consiste en extraer los datos a procesar
– reduce se centra en la agregación de los
mismos.
81

Instalación de CouchDB
• Dependencias:
Runtime Build
CouchDB Spiderm Automak
Erlang ICU cURL Autoconf
onkey e
0.9.x ==1.7 >=5.6.0 >= 3.0 >= 7.15.5 >= 1.6.3 >= 2.59
>=1.7 &&
0.10.x >=5.6.5 >= 3.0 >= 7.18.0 >= 1.6.3 >= 2.59
<=1.8.0
0.11.x >=1.7 >=5.6.5 >= 3.0 >= 7.18.0 >= 1.6.3 >= 2.59

• Detalles de instalación:
– http://wiki.apache.org/CouchDB/Installation
• Instrucciones detalladas para Windows en:
https://github.com/LearningRegistry/LearningRegistry/wiki/Windo
ws-Installation-Guide
– Curl
– Visual C++ 2008 Redistributable Setup
– OpenSSL
82
– Configurar %PATH% para que apunte a los dirs de instalación dependencias

Instalación en Windows y Linux
• Algunos enlaces de ayuda para Windows:
– http://niallodoherty.com/post.cfm/installing-CouchDB-on-
windows-quick-guide
– http://wiki.apache.org/CouchDB/Quirks_on_Windows
• Instalación en Linux:
– Tan simple como: sudo aptitude install
couchdb
– http://wiki.apache.org/couchdb/Installing_on_Ubuntu
• Para lanzar el servidor de CouchDB ejecutar el
comando couchdb en el directorio bin de
instalación.
83

Instalación CouchDB
• Sin embargo, lo más sencillo es:
– Ir a CouchBase (http://www.couchbase.com/downloads)
– Descargarse el binario de tu plataforma
• Seleccionar Enteprise Edition/Membase Server
– Abrir el administrador gráfico de bases de datos en
CouchDB, denominado Futon:
• http://127.0.0.1:5984/_utils/
• Recomendable instalar la extensión FireBug para FireFox:
http://getfirebug.com/ :
– Permite editar, depurar y monitorizar CSS, HTML y JavaScript dinámicamente
sobre cualquier página
» Características descritas en: https://getfirebug.com/whatisfirebug

84

CouchDB Futon
• Futon: http://localhost:5984/_utils/
• Hace uso internamente de la librería
http://127.0.0.1:5984/_utils/script/jquery.couch.js
• Lo primero que hay que hacer es hacer click en Fix
Me para asegurarnos que sólo usuarios autorizados
pueden acceder a CouchDB
– Nosotros usaremos la combinación
admin/enpresadigitala

85

La API RESTful JSON
• CouchDB ofrece una API como mecanismo para recuperar datos de una
BBDD.
– Donde siguiendo la convención REST: (si no aparece la sabes para crear POST y
sino PUT)
• POST – crea un nuevo registro
• GET – lee registros
• PUT – actualiza un registro
• DELETE – borra un registro
• Esta API es accesible vía HTTP GET y POST y retorna datos en el formato de
objetos JavaScript mediante JSON.
– Una ventaja de este enfoque es que puede usarse una framework AJAX como
Prototype o jQuery para crear una aplicación web, sin necesidad de hacer uso
de un lenguaje de parte servidora
– La herramienta de línea de comando CURL pueden ser usada como cliente de
línea de comandos HTTP:
• Descargable de: http://curl.haxx.se/
• Permite realizar peticiones GET, POST, PUT, y DELETE, mostrando la respuesta HTTP
recibida del servidor web
86

Probando la API RESTful de
CouchDB con curl
• $ curl http://127.0.0.1:5984/
– Respuesta: {"CouchDB":"Welcome","version":"1.1.1"}
• O explícitamente define el tipo de petición realizada a través del parámetro -X de curl:
– $ curl -X GET http://127.0.0.1:5984/_all_dbs
• Respuesta:
["_replicator","_users","nerekurtsoak","test_suite_reports","testdb","user
s"]
• Para crear dos nuevas bases de datos, ejecutaríamos los comandos:
– $ curl -uadmin:enpresadigitala -X PUT http://127.0.0.1:5984/fruit
• Respuesta: {"ok":true}
– $ curl -uadmin:enpresadigitala -X PUT
http://127.0.0.1:5984/vegetables
• Si ejecutamos ahora:
– $ curl -X GET http://127.0.0.1:5984/_all_dbs
– Obtendríamos:
["_replicator","_users","fruit","nerekurtsoak","test_suite_reports",
"testdb","users"]
• Si intentamos volver a crear una BBDD ya existente, recibimos un error:
– $ curl -X PUT http://127.0.0.1:5984/fruit
• Respuesta: {"error":"file_exists","reason":
"The database could not be created, the file already exists.“}
87

Probando la API RESTful de
CouchDB con curl
• Podemos borrar una base de datos con el siguiente comando:
– $ curl -uadmin:enpresadigitala -X DELETE
http://127.0.0.1:5984/vegetables
– Respuesta: {"ok":true}
• Para crear un documento:
– $ curl -uadmin:enpresadigitala -X PUT
http://127.0.0.1:5984/fruit/apple -H "Content-Type:
application/json" -d {}
– Respuesta: {"ok":true,"id":"apple","rev":"1-
967a00dff5e02add41819138abb3284d"}
• Para recuperarlo:
– $ curl -X GET http://127.0.0.1:5984/fruit/apple
– Respuesta: {"_id":"apple","_rev":"1-967a00dff5e02add41819138abb3284d"}
• Para recuperar información de la BBDD:
– $ curl -X GET http://127.0.0.1:5984/fruit
– Respuesta:
{"db_name":"fruit","doc_count":1,"doc_del_count":0,"update_seq":1,"p
urge_seq":0,
"compact_running":false,"disk_size":4179,"instance_start_time":"1321
991208171560","disk_format_version":5,"committed_update_seq":1}

88

Programando CouchDB
• Gracias a la API RESTful, los desarrolladores pueden
conectarse a CouchDB usando cualquier software
que soporte HTTP
• La mayoría de los lenguajes modernos ofrecen algún
tipo de interfaz HTTP, implicando que CouchDB
puede ser usada en cualquier proyecto de desarrollo.
– Revisar la siguiente página para diferentes clientes
programáticos a CouchDB:
• http://wiki.apache.org/CouchDB/Related_Projects

89

Primeros pasos con CouchDB
• Vamos a seguir el tutorial en:
http://net.tutsplus.com/tutorials/getting-
started-with-CouchDB/
– Asegúrate de crear una cuenta de
admin/enpresadigitala
• Otros tutoriales:
– http://www.catswhocode.com/blog/getting-
started-with-CouchDB-tutorial-a-beginners-guide

90

Primeros pasos en CouchDB

91

Primeros Pasos en CouchDB
• En Futon:
1. Crearemos la base de datos haciendo click en “Create Database”, de
nombre "nerekurtsoak"
2. Hacer click en “New Document”
• Vete añadiendo campos a través de “ADD Field”
– "name" : “Curso NoSQL”
– "price" : 30
• Guarda cada campo
• Guarda el documento
3. Modificar el documento ya existente añadiendo el campo "type"
con valor "course"
• La nueva versión del documento debería empezar por 2

92

Primeros Pasos en Curl
1. Creemos un documento persona.json con el siguiente contenido:
{
"forename": "Diego",
"surname": "Lopez-de-Ipina",
"type": "person"
}
2. Usamos el siguiente comando de CURL para subir el documento a
CouchDB:
– curl -X POST http://127.0.0.1:5984/nerekurtsoak/ -d
@persona.json -H "Content-Type: application/json"
– Se devolvería:
• {"ok":true,"id":"b54b3496d090c43a4266180ecb002a92","rev
":"1-93c73d298af443f623db6861f90e9f6e"}
3. Para recuperar todos los documentos:
– curl -X GET
http://127.0.0.1:5984/nerekurtsoak/_all_docs
93

Vista de un documento en Futon

94

Creando una función Map
• Seleccionar Temporary View en the Drop View
dentro de Futon
– La función map tendría el siguiente código:
function (doc) {
if (doc.type == "course" && doc.name) {
emit(doc.name, doc);
}
}
– Accede a ella a través del navegador como:
• http://127.0.0.1:5984/_utils/database.html?nerekurtsoak/_design
/courses/_view/courses

95

Creando un Reduce
• Nos aseguraremos de tener al menos dos cursos con precio
• Definir la función de mapeo como:
function (doc) {
if (doc.type === "course" && doc.price) {
emit(doc.id, doc.price);
}
}
• Definir la función reduce como:
function (keys, prices) {
return sum(prices);
}
• Guardarlo como coursePrices, asegurarse de hacer click en Reduce
• Ir a
http://127.0.0.1:5984/_utils/database.html?nerekurtsoak/_design/course
prices/_view/courseprices
96

Creando un Reduce

97

Documentos de Diseño en
CloudDB
• Los documentos de diseño son un tipo especial de documento
en CouchDB que contiene código de aplicación:
– Vistas MapReduce, validaciones, funciones show, list y update
• Se suele crear un documento de diseño por cada aplicación
• El documento de diseño es un documento CouchDB con un ID
que comienza con _design/:
– Se replica como otros documentos en la BBDD y soporta gestión de
conflictos a través del parámetro rev
• CouchDB mira las vistas y otras funciones de aplicación en él
• Los contenidos estáticos de la aplicación aparecen como
_attachments en el documento de diseño

98

Estructura interna de un
Documento de Diseño
• Están compuestos de:
– Funciones de validación
– Definición de vistas
– Funciones show, list y update
– Attachments
• Una BBDD CouchDB puede tener
varios documentos de diseño.
– _design/calendar
– _design/contacts
• Para recuperar un documento de
diseño haz un GET con el siguiente
patrón de URL:
– http://localhost:5984/my
db/_design/calendar
– http://127.0.0.1:5984/my
db/_design/contacts 99

Vistas: funciones map
• Las funciones vistas en CouchDB son strings guardados en el campo views del
documento de diseño
• Los resultados de un vista se guardan en un B-tree, al igual que todo documento
– Estos árboles permiten realizar búsquedas de filas por clave y recuperar rangos de filas
• Todas las funciones map tienen un único parámetro doc:
function(doc) {
if(doc.date && doc.title) {
emit(doc.date, doc.title);
}
}
• Las funciones map son funciones libres de efectos laterales que toman un
documento como argumento y emiten pares clave/valor:
– Generan una lista ordenada por la clave de las filas
• Tenemos varios parámetros para recuperar resultados:
– Una sola fila: _design/docs/_view/date?key="2009/01/30 18:04:11"
– Varias filas: _design/docs/_view/date?startkey="2010/01/01
00:00:00"&endkey="2010/02/00 00:00:00”&descending=true

100

Vistas: funciones reduce
• Las funciones reduce operan sobre las filas ordenadas emitidas por las
funciones map
• Dada la manera en que los árboles B-tree están estructurados, podemos
cachear los resultados intermedios de un reduce en los nodos no-hoja
• El formato de una función reduce en una vista es el siguiente:
function(keys, values, rereduce) {
return sum(values)
}
• La función reduce se ejecuta sobre cada nodo del árbol para calcular el
resultado final que es un valor escalar:
– Cuando se ejecuta sobre las hojas del árbol (que contiene filas del mapa), el
parámetro rereduce es false
– Cuando se ejecuta en los nodos internos del árbol, el valor de rereduce es
true

101

Configuración de vistas
• Se definen en el documento de diseño como sigue:
{
"_id": "_design/application",
"_rev": "1-C1687D17",
"views": {
"viewname": {
"map": "function(doc) { ... }",
"reduce": "function(keys, values) { ... }"
},
"anotherview": {
"map": "function(doc) { ... }",
"reduce": "function(keys, values) { ... }"
}
}
}
• Para acceder a ellas se realiza un HTTP GET a
/database/_design/application/_view/viewname

102

Recetas: De SQL a MapReduce
• SELECT field FROM table WHERE
value="searchterm“
– La función map sería:
function(doc) {
if(doc.age && doc.name) {
emit(doc.age, doc.name);
}
}
– Y la consulta:
/ladies/_design/ladies/_view/age?key=5

• Documentación:
http://guide.CouchDB.org/draft/cookbook.html
103

Recetas: De SQL a MapReduce
• SELECT field FROM table WHERE value LIKE "searchterm%"
– Para un documento:
{
"_id": "Hugh Laurie",
"_rev": "1-9fded7deef52ac373119d05435581edf",
"mime-type": "image/jpg",
"description": "some dude"
}
– La función map sería:
function(doc) {
if(doc["mime-type"]) {
var prefix = doc["mime-type"].match(/^[^/]+//);
if(prefix) {
emit(prefix, null);
}
}
}
– Y la consulta:
104
/files/_design/finder/_view/by-mime-type?key="image/"

Validaciones
• CouchDB usa la función validate_doc_update para evitar que documentos inválidos o
no autorizados sean procesados.
• CouchDB envía las funciones y documentos a un intérprete de JavaScript
• La función validate_doc_update se ejecuta para cada documento a crear o actualizar
– Si lanza una excepción, la actualización es rechazada
• El formato de una función de validación es el siguiente:
function(newDoc, oldDoc, userCtx) {
function require(field, message) {
message = message || "Document must have a " + field;
if (!newDoc[field]) throw({forbidden : message});
};
if (newDoc.type == "post") {
require("title");
require("created_at");
require("body");
require("author");
}
}
105

Funciones show y list
• CouchDB permite generar respuestas en formatos distintos a JSON
• Los campos del documento de diseño show y list contienen funciones utilizadas para
transformar documentos JSON en HTML, XML u otros Content-Types
• Estas funciones son como acciones de una framework web, pero no tienen efectos laterales,
es decir, solamente realizan peticiones de recuperación de información, no cambian nada o
inician procesos o lanzan otras funciones
• Las funciones show se invocan del siguiente modo:
– GET /mydb/_design/mydesign/_show/myshow/72d43a93eb74b5f2
• donde myshow es una entrada dentro del campo shows del documento de diseño y
72d43a93eb74b5f2 es la clave del documento a mostrar
• El formato de una función show es:
function(doc, req) {
return "<p>Aye aye, " + req.parrot + "!</p>";
}
• Se suelen utilizar combinados con plantillas y con macros JavaScript de couchapp
como !code y !json

106

Función list
• Las funciones list en CouchDB permiten generar salida de vistas en cualquier formato
– Son guardadas bajo el campo lists del documento de diseño:
{
"_id" : "_design/foo",
"_rev" : "1-67at7bg",
"lists" : {
"bar" : "function(head, req) { var row; while (row = getRow()) { ... } }",
"zoom" : "function() { return 'zoom!' }",
}
}
• La función es invocada con dos argumentos: head y req
– Donde head tiene el formato: {total_rows:10, offset:0}
– Donde req es el mismo objeto que reciben las funciones show, update y filter, conteniendo:
{ "info": {
"db_name": "test_suite_db","doc_count": 11,"doc_del_count": 0,
"update_seq": 11,"purge_seq": 0,"compact_running": false,"disk_size": 4930,
"instance_start_time": "1250046852578425","disk_format_version": 4},
"method": "GET",
"path": ["test_suite_db","_design","lists","_list","basicJSON","basicView"],
"query": {"foo":"bar"},
"headers":
{"Accept": "text/html,application/xhtml+xml ,application/xml;q=0.9,*/*;q=0.8",
"Accept-Charset": "ISO-8859-1,utf-8;q=0.7,*;q=0.7","Accept-Encoding":
"gzip,deflate","Accept-Language": "en-us,en;q=0.5","Connection": "keep-alive", …}
"body": "undefined",
"form": {},
"userCtx": {"db": "test_suite_db","name": null,"roles": ["_admin"]}
}
107

Función list
• Para ejecutar una función list usamos el siguiente formato:
/db/_design/foo/_list/list-name/view-name
– Dado que el nombre de la lista y de la vista son especificados, esto implica que es
posible usar la lista para más de una vista.
• Una función list de ejemplo sería:
function(head, req) {
var row;
start({
"headers": {
"Content-Type": "text/html"
}
});
while(row = getRow()) {
send(row.value);
}
}
• Documentación de funciones show y list en:
http://wiki.apache.org/CouchDB/Formatting_with_Show_and_List
108

Función update
• La función update se utiliza para gestionar POSTs y transformarlos en nuevos documentos
– Son funciones que los clientes invocan para crear o actualizar documentos
– Devuelven el nuevo documento y una respuesta al cliente
– Para modificar, enviar petición PUT en el formato:
• /<database>/_design/<design>/_update/<function>/<docid>
– Para crear una nueva instancia, hacer POST en el formato:
• /<database>/_design/<design>/_update/<function>
• En el documento de diseño se crearía lo siguiente:
{ updates: {
"hello" : "function(doc, req) {
if (!doc) {
if (req.id) {
return [{
_id : req.id
}, 'New World']
}
return [null, 'Empty World'];
}
doc.world = 'hello';
doc.edited_by = req.userCtx;
return [doc, 'hello doc'];
}
}
• 109
Documentación en: http://wiki.apache.org/CouchDB/Document_Update_Handlers

CouchApp
• A CouchApp es una framework para la creación de
aplicaciones JavaScript con CouchDB
– Como son aplicaciones JavaScript y HTML5 son servidas
directamente desde CouchDB
– Como efecto lateral consigues la flexibilidad y escalabilidad de
CouchDB
• http://couchapp.org/
• Para crear una CouchApp, necesitas un modo para meter
JavaScript, HTML y otros recursos en CouchDB
– La herramienta CouchApp escrita en Python es la recomendada para
generar plantillas de código en tu aplicación y volcarlos a una instancia
de CouchDB:
• http://couchapp.org/page/couchapp-python
110

CouchApp
• CouchApp te simplifica la labor de crear aplicaciones web a
partir de CouchDB:
– Fragmenta un documento de diseño en un conjunto de directorios y
ficheros del sistema local, representando views, shows, validations,
attachments, etc. que serán enviados al servidor CouchDB
• Una aplicación de Couch, CouchApp, sigue más o menos el
patrón de diseño Modelo/Vista/Controlador:
– CouchDB es el Modelo
– El árbol DOM representando el HTML mostrado al usuario sería la vista
– El JavaScript sería el Controller

111

Instalación de CouchApp
• Requiere la última versión de Python 2.x
– Para las distintas plataformas seguir las instrucciones en:
• http://couchapp.org/page/installing
– En Windows:
• Seguir instrucciones de: http://couchapp.org/page/windows-python-
installers
– Instalar Python 2.7.2: http://www.python.org/download/releases/2.7.2/
– Instalar la herramienta setuptools que incluye instalador de aplicaciones
que permite descargar, construir, instalar y gestionar paquetes Python
automáticamente
» http://packages.python.org/distribute/easy_install.html
• Añadir a PATH C:ProgrammingPython27Scripts
– Instalar las extensiones de Python para Windows: pywin32-214.win32-
py2.7.exe
– Instalar Couchapp-0.7.5.win32.exe

112

Hola Mundo con CouchApp
• Los pasos a seguir serán los siguientes:
1. Usar el comando couchapp para que genere la estructura de tu
aplicación:
• couchapp generate helloworld
2. Crear una función show que devuelve el mensaje "Hello world"
• cd helloworld
• couchapp generate show hello
• Editar el fichero generado "hello.js" con el siguiente contenido:
function(doc, req) {
return "Hello World";
}
3. Subirlo a tu servidor de bases de datos, bajo la base de datos,
http://127.0.0.1:5984/testdb :
• couchapp push testdb
• couchapp push .
http://admin:enpresadigitala@127.0.0.1:5984/testdb

113

Hola Mundo con CouchApp
4. Comprobar que se ha subido correctamente yendo a:
• http://127.0.0.1:5984/testdb/_design/helloworld/_show/hello
5. Se puede clonar una aplicación ya existente con el siguiente
comando, que cogería una nueva versión en helloworld2:
• couchapp clone
http://127.0.0.1:5984/testdb/_design/helloworld
helloworld2

114

Mi primera aplicación seria
con CouchApp
• El objetivo es crear un libro de direcciones usando HTML5 servido desde
CouchApp
– Cogido de: http://blog.edparcell.com/using-jquery-and-CouchDB-to-build-a-
simple-we
• Los pasos a seguir:
1. Crear base de datos "addressbook" con Futon
2. Crea los siguientes dos documentos en la base de datos:
{"type": "address", "name": "Fred", "mobile": "555-
0001"}
{"type": "address", "name": "Barney", "mobile": "555-
0002"}
3. Generamos la aplicación y una vista para ella, subiendo la aplicación:
• couchapp generate app addressbook
• couchapp generate view addressbook phonenumbers
• couchapp push
addressbook http://127.0.0.1:5984/addressbook
115

con CouchApp
4. Una vez creada la vista, la editamos de la siguiente manera:
– Borramos addressbook/views/phonenumbers/reduce.js
– Editamos el fichero addressbook/views/phonenumbers/map.js
con:
function(doc) {
if (doc.type && doc.type == "address" && doc.name && doc.mobile) {
emit(doc.name, doc.mobile);
}
}

5. Comprueba que funciona la vista yendo a:
http://127.0.0.1:5984/addressbook/_design/addressbook/_v
iew/phonenumbers

116

con CouchApp
6. Modifica el contenido de _attachments index.html con lo siguiente, súbelo a CouchDB y vete a
http://127.0.0.1:5984/addressbook/_design/addressbook/index.html:
<!DOCTYPE html>
<html>
<head>
<title>Simple address book</title>
<link rel="stylesheet" href="style/main.css" type="text/css">
<span style="white-space: pre;"> </span><script src="/_utils/script/json2.js"></script>
<span style="white-space: pre;"> </span><script
src="/_utils/script/jquery.js?1.3.1"></script>
<span style="white-space: pre;"> </span><script
src="/_utils/script/jquery.couch.js?0.9.0"></script>
<span style="white-space: pre;"> </span><script type="text/javascript">
<span style="white-space: pre;"> </span></script>
</head>
<body>
<h1>Simple address book</h1>
<span style="white-space: pre;"> </span><div id="add"><button type="button"
id="add">Add</button></div>
<div id="addressbook"></div>
</body>
</html>

117

con CouchApp
7. Modificamos el index.html introduciendo JavaScript que se activa cuando la página acaba de cargarse.
– El código añadido recupera un documento JSON de la vista phonenumbers desde CouchDB
– Itera sobre cada fila de la vista, añadiendo un elemento div por cada fila conteniendo el nombre, phonenumber y enlaces para editarlos
y borrarlos:
$db = $.couch.db("addressbook");
function refreshAddressbook(){
$("div#addressbook").empty();
$db.view("addressbook/phonenumbers", {
success: function(data){
for (i in data.rows) {
id = data.rows[i].id;
name = data.rows[i].key;
phonenumber = data.rows[i].value;
html = '<div class="address">' +
'<span class="name">' + name + '</span> ' +
'<span class="phonenumber">' + phonenumber + '</span>  ' +
'<a href="#" id="' + id + '" class="edit">edit</a> | ' +
'<a href="#" id="' + id + '" class="delete">delete</a>' +
'</div>';
$("div#addressbook").append(html);
}
}
});
}
$(document).ready(function() {
refreshAddressbook();
});
8. Lo subimos al servidor: couchapp push addressbook http://127.0.0.1:5984/addressbook

118

con CouchApp
9. Para añadir elementos añadimos el siguiente formulario web:
function addUpdateForm(target, existingDoc) {
html = '<form name="update" id="update" action=""><table>' +
'<tr><td>Name</td><td>Number</td></tr>' +
'<tr>' +
'<td><input type="text" name="name" id="name" value="' +
(existingDoc ? existingDoc.name : "" ) + '"></td>' +
'<td><input type="text" name="mobile" id="mobile" value="' +
(existingDoc ? existingDoc.mobile : "") + '"></td>' +
'</tr><tr>' +
'<td><input type="submit" name="submit" class="update" value="' +
(existingDoc ? "Update" : "Add") + '"></td>' +
'<td><input type="submit" name="cancel" class="cancel" value="Cancel"/></td>' +
'</tr>' +
'</table></form>';
target.append(html);
target.children("form#update").data("existingDoc", existingDoc);
}
10. Para editar el formulario deberíamos hacer:
id = $tgt.attr("id");
if ($tgt.hasClass("edit")){
if ($tgt.hasClass("edit")) {
$("button#add").show();
$("form#update").remove();
$db.openDoc(id, { success: function(doc) {
addUpdateForm($tgt.parent(), doc);
}});
} 119
}

con CouchApp
11. Y para añadirlo:
$("button#add").click(function(event) {
$("button#add").hide();
addUpdateForm($("div#add"));
});

12. Finalmente añadimos la parte de lógica para añadir y editar elementos:
$("input.update").live('click', function(event) {
var $tgt = $(event.target);
var $form = $tgt.parents("form#update");
var $doc = $form.data('existingDoc') || {};
$doc.type = "address";
$doc.name = $form.find("input#name").val();
$doc.mobile = $form.find("input#mobile").val();
$db.saveDoc(
$doc, {
success: function(){
$("button#add").show();
}
}
);
return false;
})

120

con CouchApp
13. Modify index.html to allow contact deleting:
$(document).ready(function() {
$("div#addressbook").click(function(event) {
var $tgt = $(event.target);
if ($tgt.is('a')) {
id = $tgt.attr("id");
if ($tgt.hasClass("edit")) {
// TODO: implement edit functionality
}
if ($tgt.hasClass("delete")) {
html = '<span class="deleteconfirm">Sure? <a href="#" class="dodelete">Yes</a> <a
href="#" class="canceldelete">No</a></span>';
$tgt.parent().append(html);
}
if ($tgt.hasClass("dodelete")) {
$db.openDoc(id, { success: function(doc) {
$db.removeDoc(doc, { success: function() {
$tgt.parents("div.address").remove();
}})
}});
}
if ($tgt.hasClass("canceldelete")) {
$tgt.parents("span.deleteconfirm").remove();
}
}
}); 121
});

con CouchApp
14. Finalmente habría que subir la aplicación a CouchDB con el comando:
$ cd <parent-dir-addressbook-app>
$ couchapp push addressbook
http://admin:enpresadigitala@127.0.0.1:5984/addressbook

• Un ejemplo completo de CouchApp que incluye todas las características
(funciones) de un documento de diseño puede encontrarse en:
– Sofa-blog: https://github.com/jchris/sofa
• Para instalar: couchapp push .
http://admin:enpresadigitala@127.0.0.1:5984/myblogdb
– La implementación de esta aplicación es descrita paso a paso en:
http://guide.CouchDB.org/editions/1/en/standalone.html

122

Escalabilidad en CouchDB
• CouchDB permite hacer escalado en tres
niveles:
– Escalando peticiones de lectura
• Se resuelve mediante una caché
– Escalando peticiones de escritura
• Hay que utilizar técnicas de scaling
– Escalando datos
• La solución es dividir los datos en cachos (chunks) y
colocarlos en diferentes servidores
– Todos los servidores conteniendo chunks conforman un
clúster
123

Replicación en CouchDB

• La replicación sincroniza dos copias de la misma
BBDD, permitiendo que los usuarios tengan baja
latencia de acceso a datos independientemente de
su localización
– La replicación consiste en enviar una petición HTTP a un
servidor CouchDB incluyendo una BBDD de origen y otra
de destino, haciendo que CouchDB envíe los cambios del
origen al destino:
• POST /_replicate HTTP/1.1
{"source":"database","target":http://example.
org/database}

124

Replicación en CouchDB
• Para enviar cambios se sigue utilizando la misma llamada
– Cuando solicitas a CouchDB que replique una BBDD en otra,
comparará ambas para encontrar qué documentos en el origen
difieren de los del destino y luego enviará todos los cambios al destino
en batch
• Las bases de datos en CouchDB tienen un número de secuencia que es
incrementado cada vez que la BBDD se cambia
• Hay diferentes modos de replicación:
– Replicación normal, en demanda
– Replicación continua, cada vez que produce un cambio éste se
propaga
• Añades "continuous":true al objeto de lanzamiento de replicación
• CouchDB hará uso de la _changes API sobre cambios en documentos

125

Replicación con Futon
• Abre tu navegador en Futon: http://127.0.0.1:5984/_utils/
– Haz clic en Replicator
– Selecciona BBDD a replicar
– Haz clic en continuous
– Haz clic en el botón Replicate
• Alternativamente desde línea de comando:
– curl -uadmin:enpresadigitala -X DELETE
http://127.0.0.1:5984/nerekurtsoak_rep2
– curl -uadmin:enpresadigitala -X PUT
http://127.0.0.1:5984/nerekurtsoak_rep2
– curl -uadmin:enpresadigitala -X POST
http://127.0.0.1:5984/_replicate -H "Content-Type:
application/json" -d @replication-example.json
• Donde replication-example.json contiene:
– '{"source":"http://127.0.0.1:5984/nerekurtsoak",
"target":http://admin:enpresadigitala@127.0.0.1:5984/nereku
rtsoak_rep2, "continuous":true}'

126

Gestión de Conflictos
• Cuando replicas dos BBDD en CouchDB y se identifican
conflictos, CouchDB los señala en los documentos afectados
con el atributo "_conflicts":true
– La versión que es seleccionada como última es la versión ganadora.
– La revision perdedora es almacenada como versión anterior.
– CouchDB no hace un merge de las revisiones conflictivas.
• Tu aplicación es la que resuelve programáticamente los conflictos
– La replicación garantiza que los conflictos se detecten y que cada
instancia de CouchDB haga la misma selección respecto a ganadores y
perdedores, independientemente de las instancias que existan.

127

Resolución de conflictos por
ejemplo
• La base de datos A se replica en B:

• Creamos un documento en A

• Forzamos replicación:

128

ejemplo
• Creamos una nueva versión del documento en B:

• Añadimos una nueva versión en A:

129

ejemplo
• Cuando replicamos ahora A en B, se detecta un
conflicto:

• La aplicación resuelve el conflicto

130

Puesta en práctica de
Replicación
• Creamos una BD y una réplica:
127.0.0.1:5984/db
127.0.0.1:5984/db-replica
127.0.0.1:5984/db/foo -d @foo.json
– curl -uadmin:enpresadigitala -X POST
http://127.0.0.1:5984/_replicate -H "Content-
Type: application/json" -d @replication-
conflict-example.json

131

Replicación
– Actualizamos ahora el documento en db-replica a la versión 2:
• curl -X PUT 127.0.0.1:5984/db-replica/foo -d
'{"count":2,"_rev":"1-
74620ecf527d29daaab9c2b465fbce66"}'
– Creamos el conflicto cambiando la versión del documento en db a 3:
• curl -uadmin:enpresadigitala -X PUT
127.0.0.1:5984/db/foo -d '{"count":3,"_rev":"1-
74620ecf527d29daaab9c2b465fbce66"}„
– Volvemos a replicar la BBDD:
• curl -uadmin:enpresadigitala -X POST
http://127.0.0.1:5984/_replicate -H "Content-Type:
application/json" -d @replication-conflict-example.json

132

Replicación
– Para ver si tenemos conflictos creamos una vista en db-replica con Futon
con el siguiente contenido:
function(doc) {
if(doc._conflicts) {
emit(doc._conflicts, null);
}
}
– Ejecutamos la vista yendo a: http://127.0.0.1:5984/db-
replica/_design/conflicts/_view/conflicts
• Resultado: {"total_rows":1,"offset":0,"rows":[
{"id":"foo","key":["2-
7c971bb974251ae8541b8fe045964219"],"value":null} ]}
– La revisión con el mayor número histórico de revisiones o con una clave de
revisión menor que la otra es la seleccionada

133

Algunos ejemplos de CouchApp
• Revisar documentación en:
– http://couchapp.org/page/index
• Instalación de Pages:
couchapp push pages
http://admin:enpresadigitala@127.0
.0.1:5984/pages
– Ir a:
http://127.0.0.1:5984/pages/_design/page
s/_rewrite/page/index

134

Notificaciones de cambios
• CouchDB ofrece un mecanismo de subscripciones a cambios
mediante la API _changes
• La API _changes suministra información en el siguiente
formato:
– {"seq":12,"id":"foo","changes":[{"rev":"1-
23202479633c2b380f79507a776743d5"}]}
• Donde seq es un valor que va cambiando cada vez que se produce un
cambio en una BBDD
• id es el identificador del documento
• El campos changes suele contener una descripción de las últimas
modificaciones

135

Probando la API _changes
• Creamos una BBDD:
– $ curl -X PUT http://127.0.0.1:5984/db-changes
• Revisamos si ha habido cambios:
– $ curl -X GET http://127.0.0.1:5984/db-changes /_changes
• Devuelve:
– {"results":[], "last_seq":0}

• Añadimos un documento:
– $ curl -X PUT http://127.0.0.1:5984/db-changes/test -d
'{"name":"Anna"}„
• Revisamos si ha habido cambios de nuevo:
– {"results":[{"seq":1,"id":"test","changes":[{"rev":"1-
aaa8e2a031bca334f50b48b6682fb486"}]}], "last_seq":1}
• Podemos usar el parámetro since para filtrar resultados y longpoll para
quedarse bloqueado hasta un nuevo cambio:
– $ curl -X GET $HOST/db/_changes?feed=longpoll&since=1

136

Probando la API _changes
• Long polling requiere abrir una nueva conexión HTTP por cada cambio notificado.
• La API continuous changes permite establecer una conexión permanente entre tu aplicación
y CouchDB para recibir cambios:
– $ curl -X GET "$HOST/db/_changes?feed=continuous&since=3"
• Podemos definir filtros para refinar los cambios en los que estamos interesados. Por ejemplo:
{
"_id": "_design/app",
"_rev": "1-b20db05077a51944afd11dcb3a6f18f1",
"filters": {
"important":
"function(doc, req) {
if(doc.priority == 'high') { return true; }
else { return false; }
}"
}
}
• Para ver los cambios filtrados invocaríamos:
$ curl "$HOST/db/_changes?filter=app/important"
137

APIs JavaScript para
CouchApp
• Tutorial de JSON:
– http://guide.CouchDB.org/editions/1/en/json.html
• Tutoriales de jQuery:
– http://docs.jquery.com/Tutorials
– jQuery.ajax():
• http://api.jquery.com/jQuery.ajax/#jQuery-ajax-settings
• Hay un plugin jQuery para CouchDB:
– http://bradley-holt.com/2011/07/CouchDB-jquery-plugin-
reference/
– API en:
• http://daleharvey.github.com/jquery.couch.js-
docs/symbols/index.html
138

Mustache
• Una manera cómoda de genera documentos HTML es a través de librerías de plantillas como Mustache
– Funciona expandiendo tags en una plantilla usando valores de un mapa
• Ejemplo:
– El texto de entrada sería:
Hello {{name}}
You have just won ${{value}}!
{{#in_ca}}
Well, ${{taxed_value}}, after taxes.
{{/in_ca}}
– Dado el siguiente diccionario:
{
"name": "Chris",
"value": 10000,
"taxed_value": 10000 - (10000 * 0.4),
"in_ca": true
}
– Produciría los siguientes resultados:
Hello Chris
You have just won $10000!
Well, $6000.0, after taxes.
• Tutorial en: http://mustache.github.com/mustache.5.html

139

NoSQL: la siguiente generación de Base de Datos

NoSQL: la siguiente generación de Base de Datos

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Destaque

Destaque (14)

Semelhante a NoSQL: la siguiente generación de Base de Datos

Semelhante a NoSQL: la siguiente generación de Base de Datos (20)

Mais de Diego López-de-Ipiña González-de-Artaza

Mais de Diego López-de-Ipiña González-de-Artaza (20)

Último

Último (20)

NoSQL: la siguiente generación de Base de Datos