- 
Relaxez-vous
- 
Oubliez SQL
- Le temps d'une minute, oubliez tout ce que vous connaissez sur les données relationnelles, la normalisation et autres termes du genre.
- Tout ce que vous voulez, c'est... gérer des données.
 
- SQL est le choix le plus souvent pris pour gerer une grand nombre de donné
- Reste le fs, les bases clés/valeurs ...
 
 
- 
Gérer des données c'est ...
    - Les sauver
        
            - sauver de manière sécurisée et permanente (ACID, ...)
- sauver de manière efficiente (schema, ...)
 
- les voir
    
        - rendre les données facilement accessibles
- fournir des possibilités de recherche avancées (fulltext)
 
- les sécuriser
- les partager
    
        - de manière distribuée
- en ligne et hors ligne !
 
 
- ACID : Atomicité, Cohérence, Isolation, Durée(Permanence)
- Aujourd'hui les données ne sont pas figées, elles évoluent, ne plus penser en terme de table mais en terme de schema évolutif
- Une fois les données sauvées, ce qui importe c'est de les voir et de la manière la plus souple possible. Reproduire la feuille de papier
- Les partager: clusters, offline pour les commerciaux par ex, update des données en cours de route, synchronisation ...
 
 
- 
Bienvenue Apache CouchDB
    - CouchDB répond de manière simpleau problématiques précendentes
- CouchDB y répond en utilisant les nouveaux paradigmes
 
- 
Documents
    - Dictionnaires de données
- stockés sous forme d'objets Json
- peuvent avoir d'autres données attachées
- id unique et numéro de revision
 
- 
Exemple de document :
{
  _id:”098F6BCD4621D373CADE4E832627B4F6”,
  _rev: 4134847,
  “username”: “benoitc”,
  “email”: “benoitc@e-engura.com“,
  “password“: “da39a3ee5e6b4b0d3255bfef95601890afd80709“
  “visites”: 10,
  “created“": “2008-05-15T23:31:19Z“
}
- 
Une api REST
    - Données aisemment accessibles par HTTP : HEAD, GET, PUT, POST, DELETE...
- Données échangées au format Json
- Exemples d'urls :
    
        - http://server/company/_all_docs
- http://server/company/765432
- http://server/company/_design/people
- http://server/company/_design/people?count=7&startkey=”L”&endkey=”M”
 
 
- 
Vues & Map/Reduce
    - Javascript est utilisé pour gérer la reconnaissance des schema de documents
- Map/Reduce est utilisé pour définir des groupes de documents
- Javascript embarqué mais les vues peuvent être aussi gérées en python
 
- 
Localisons les documents / tags
    
        |  |  | 
    
        | Clé | Valeur |  
        | family | 1 |  
        | amis | 1 |  
        | amis | 1 |  
        | travail | 1 |  
        | travail | 1 |  
        | impact | 1 |  |  
 
- 
    Vue : localisons les tags (Map)
- 
Réduisons les tags
 
    
        | 
    
        | Clé | Valeur |  
        | famille | 1 |  
        | amis | 1 |  
        | amis | 1 |  
        | travail | 1 |  
        | travail | 1 |  
        | impact | 1 |  |  | 
    
        | Clé | Valeur |  
        | famille | 1 |  
        | amis | 2 |  
        | travail | 2 |  
        | impact | 1 |  |  
 
- 
    Vue pour réduire les tags:
- 
Couchdb en résumé
    
        | Un système robuste de stockage de données | Réplication |  
        | Une API REST dialoguant en utilisant Json | Map/Reduce |  
        | Un système de vue en Javascript (ou en python !) | développé en Erlang/OTP |  
        | Recherche fulltext | Ajoutez votre fonctionnalité ici, c'est opensource! |  
 
- 
Architecture CouchDB
      
 
- 
    Démo
- 
CouchDB et python
    - Un mariage de raison
- Erlang, le langage idéal pour développer une architecture distribuée résistante
- Python, le langage agile pour le frontend et les interfaces ne requérant pas
    de distribution et parralélisation
- Json la glue idéale.
 
- 
2 clients python et 1 boîte à outils
    - couchdb-python, le plus complet
- paisley, le client couchdb asynchrone basé sur twisted
- enkicms, un framework  web basé sur couchdb
 
- 
couchdb-python
- 
un client orienté autour de 5 objets
    - La plupart des objets de couchdb-python se comportent comme des dict: fonctionnalités __iter__, __setitem__, __getitem__, len...
- L'objet Server: accès au serveur couchdb via une url, gestion des bases de documents
- Objet Database: dict donnant accès aux documents.
- Objet Document, dict représentant un document avec 2 propriétés en plus : id et rev
- Objet View et ses descendant TemporaryView, PermanentView, ittérer ses objet renvoient des objets ViewResults
 
- 
l'exemple de friendpaste
    - Friendpaste, un pastebin innovant basé sur couchdb vous permettant de voir les différentes révisions d'un paste.
-  et son cousin Pypaste
- Utilisation du "mapping objet", appel de vues, création de documents
- Utilise aussi Wekzeug, Jinja et Pygments.
 
- 
accès à la base de donnée
# init views and create db
couchdb_server = Server(settings.SERVER_URI)
try:
    self.db = couchdb_server.create(settings.DATABASE_NAME)
except ResourceConflict:
    self.db = couchdb_server[settings.DATABASE_NAME]
- 
le document Paste et sa révsionUn objet héritant Document:
 class Snippet(Document):
    title=TextField()
    type=TextField(default='snippet')
    parent=TextField(default='')
    revid = TextField()
    snippet=TextField()
    language=TextField()
    created = DateTimeField()
    updated = DateTimeField()
    def store(self, db):
        """override store procedure to generate small id""""
- 
Sauver le documentOn sauve le document en passant à la fonction store la base où il doit être sauvé :
 
s = Snippet(
                    title=d.get('title', ""),
                    snippet=d.get('snippet'),
                    language=d.get('language', 'text')
            )
s.store(local.application.db)
- 
Récupérer les révisions du document
    - Attention, les vues ne sont reindexées qu'à chaque appel de celles-ci. Peut créer des problèmes de lenteurs.
- Appeler la vue le plus tard possible ou gérer une tâche en arrière plan qui appelle celle-ci tous les n docs
-  la vue :
function(doc) { 
  if (doc.type == "revision") { 
    map([doc.parent,doc.updated], doc); 
  } 
  if (doc.type == "snippet") { 
    map([doc._id,doc.updated], doc); 
  }
}
 
- 
Récupérer la vuedef _get_snippet_revisions(id): 
    try:
        r = local.application.db.view('_view/paste/by_id', startkey=[str(id)], endkey=[str(id),10])
    except:
        raise NotFound
    results = [r for r in res.__iter__()]
    return results
def get_snippet(id, rev=None):
    revisions = {}
    res = _get_snippet_revisions(id)
    if len(res) > 1:
        revisions = res[1:]
        revisions.sort(lambda a,b: cmp(a.key[1], b.key[1]))
        revisions.reverse()
- 
    Démo
- 
Paisley
    - librairie asynchrone basé sur twisted
- client simple, pas de gestion de mapping actuellement. Prévu pour la version 0.2
- Un seul objet à appeler pour gérer les créations de documents, base
- https://code.launchpad.net/paisley/
 
- 
Exemple de Paisley
import paisley
from twisted.internet import reactor, defer
from twisted.web import client
client.HTTPClientFactory.noisy = False
def test():
    foo = paisley.CouchDB('localhost')
    d = foo.createDB('mydb')
    wfd = defer.waitForDeferred(d)
    yield wfd
    print wfd.getResult()
    d = foo.saveDoc('mydb', '{"value":{"Subject":"I like Planktion"}}', 'mydoc')
    wfd = defer.waitForDeferred(d)
    yield wfd
    print wfd.getResult()
    reactor.stop()
test = defer.deferredGenerator(test)
if __name__ == "__main__":
    reactor.callWhenRunning(test)
    reactor.run()
- 
EnkiCMS opensource engine
    - Un framework web opensource autour de CouchDB
- Objectif: fournir un environnement simple mais puissant permettant de créer un site web rapidement.
- Utilise Wekzeug et Jinja
- Partie opensource d'un service web qui sortira fin mai accessible seulement via hg pour l'instant :
 http://dev.e-engura.com/hg/enkicms
 
- 
EnkiCMS en bref
    - Un client couchdb basé sur couchdb-python.
- Un système de session, géneration de flux rss & atom
- Gestion de templates, context processors, et middleware àla django
- Une extension permettant de gérer des utilisateurs "classiquemen" ou via openid.
- plus à venir ...
 
- 
    Questions
- 
Quelques liens