PouchDB - Guide rapide

Ce chapitre fournit une brève introduction à PouchDB avec ses fonctionnalités et son fonctionnement.

Qu'est-ce que PouchDB?

PouchDB est une open source in-browser database APIécrit en JavaScript. Il est calqué sur Couch DB & minuss; une base de données NoSQL. En utilisant cette API, nous pouvons créer des applications qui fonctionnent hors ligne et en ligne. Il utilise en interne WebSQL et IndexedDB pour stocker les données.

Comment ça marche?

Dans PouchDB, lorsque l'application est hors ligne, les données sont stockées localement à l'aide de WebSQL et IndexedDB dans le navigateur. Lorsque l'application est de nouveau en ligne, elle est synchronisée avec CouchDB et les serveurs compatibles.

En utilisant PouchDB, vous pouvez communiquer de manière transparente avec les bases de données locales et distantes sans remarquer aucune différence.

Caractéristiques de PouchDB

Voici les caractéristiques de PouchDB -

Cross Browser - L'API fournie par PouchDB fonctionne de la même manière dans tous les environnements, nous pouvons donc exécuter une application PouchDB dans différents navigateurs.
Light Weight - PouchDB est une API très légère, elle est également incluse facilement en utilisant simplement une balise de script.
Easy to Learn - Si vous avez une connaissance préalable d'un langage de programmation, il est facile d'apprendre PouchDB.
Open Source - PouchDB est une application Open Source et est disponible sur GitHub.

Avantages de PouchDB

Voici les avantages de PouchDB -

Étant donné que PouchDB réside dans le navigateur, il n'est pas nécessaire d'effectuer des requêtes sur le réseau, cela se traduit par une exécution plus rapide des requêtes.
Vous pouvez synchroniser les données avec l'un des serveurs pris en charge et, ce faisant, vous pouvez exécuter des applications en ligne et hors ligne.

Navigateurs prenant en charge PouchDB

Voici les navigateurs prenant en charge PouchDB -

Firefox 29+ (y compris Firefox OS et Firefox pour Android)
Chrome 30+
Safari 5+
Internet Explorer 10+
Opera 21+
Android 4.0 ou version ultérieure
iOS 7.1+
Windows Phone 8+

Ce chapitre explique comment télécharger et installer PouchDB sur votre système.

Installation de PouchDB

Pour travailler avec PouchDB, vous devez télécharger le fichier .jsfichier et incluez-le dans votre script. Voici les étapes pour installer PouchDB.

Étape 1

Visitez la page d'accueil du site PouchDB, en cliquant sur le lien suivant -

https://PouchDB.com/

Étape 2

Cliquez sur le bouton Télécharger en haut à droite de la page Web, comme indiqué dans la capture d'écran ci-dessus. Cela va téléchargerPouchDB-5.3.0.min.js dans votre système.

Étape 3

Copiez et collez le PouchDB-5.3.0.min.js dans votre répertoire de travail et incluez-le dans votre JavaScript comme indiqué dans la commande suivante.

<script src = "PouchDB-5.3.0.min.js"></script>

Installation de Pouch à l'aide de Node.js

Vous pouvez également installer PouchDB en tant que module Node.js. Voici les étapes pour installer PouchDB à l'aide de Node.js.

Étape 1

Installez Node.js en suivant les étapes indiquées dans la section Installation de Node.js de notre didacticiel de script coffee .

Étape 2

Ouvrez l'invite de commande et exécutez la commande suivante. Cela installera le module de nœud PouchDB dans votre système.

npm install --save PouchDB

Téléchargement de CouchDB

Lorsqu'il est hors ligne, PouchDB stocke les données localement et fonctionne comme une application. Vous pouvez y accéder en ligne en vous connectant à des serveurs compatibles. Comme nous le savons, PouchDB peut être connecté à CouchDB, installons également CouchDB. Voici les étapes pour installer CouchDB.

Étape 1

Le site officiel de CouchDB est http://couchdb.apache.org. Si vous cliquez sur le lien donné, vous pouvez obtenir la page d'accueil du site officiel de CouchDB comme indiqué dans la capture d'écran suivante.

Étape 2

Si vous cliquez sur le bouton de téléchargement qui mènera à une page où les liens de téléchargement de CouchDB dans différents formats sont fournis. L'instantané suivant illustre la même chose.

Étape 3

Choisissez le lien de téléchargement pour les systèmes Windows et sélectionnez l'un des miroirs fournis pour démarrer votre téléchargement.

Installer CouchDB

Un exécutable Windows setup-couchdb-1.6.1_R16B02.exeLe fichier sera téléchargé sur votre système. Exécutez le fichier d'installation et poursuivez l'installation.

Après avoir installé CouchDB dans votre système avec succès, ouvrez le dossier dans lequel CouchDB a été installé, accédez au dossier bin et démarrez le serveur en exécutant un fichier de script nommé couchdb.bat.

Après l'installation, ouvrez l'interface Web intégrée de CouchDB en visitant le lien suivant - http://127.0.0.1:5984/. Si tout se passe bien, cela vous donnera une page Web, qui aura la sortie suivante.

{                 
   "couchdb":"Welcome","uuid":"c8d48ac61bb497f4692b346e0f400d60",
   "version":"1. 6.1",
   "vendor": {
      "version":"1.6.1","name":"The Apache Software Foundation"
   } 
}

Vous pouvez interagir avec l'interface Web CouchDB en utilisant l'URL suivante -

http://127.0.0.1:5984/_utils/

Cela vous montre la page d'index de Futon, qui est l'interface Web de CouchDB.

Vous pouvez créer une base de données dans PouchDB à l'aide du constructeur PouchDB.

Syntaxe

Voici la syntaxe d'utilisation du constructeur PouchDB. Pour cela, vous devez passer le nom de la base de données en paramètre.

new PouchDB(Database_name)

Exemple

Pour créer une base de données dans PouchDB en utilisant node, tout d'abord, vous devez avoir besoin du package PouchDB en utilisant le require() méthode, puis vous pouvez créer une base de données comme indiqué dans l'exemple suivant.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');
console.log ("Database created Successfully.");

Enregistrez le code ci-dessus dans un fichier avec le nom Create_Database.js. Ouvrez l'invite de commande et exécutez le fichier JavaScript en utilisantnode comme indiqué ci-dessous.

C:\PouchDB_Examples>node Create_Database.js

Cela créera une base de données localement (vous pouvez voir le dossier dans le répertoire actuel) affichant le message suivant.

Database created Successfully.

Vous pouvez obtenir les informations de base sur la base de données en utilisant la méthode nommée info()

Syntaxe

Voici la syntaxe d'utilisation du info()méthode de PouchDB. Cette méthode accepte une fonction de rappel.

db.info([callback])

Exemple

Voici un exemple de récupération d'informations de base de données à l'aide de info()méthode. Ici, nous affichons les informations de la base de données nomméemy_database. En cas d'erreur, l'erreur sera affichée sur la console.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Database information
db.info(function(err, info) {
   if (err) {
      return console.log(err);
   } else {
      console.log(info);
   }
});

Enregistrez le code ci-dessus dans un fichier avec le nom Database_info.js. Ouvrez l'invite de commande et exécutez le fichier JavaScript en utilisantnode comme indiqué ci-dessous.

C:\PouchDB_Examples>node Database_info.js

Cela affichera les informations de la base de données spécifiée comme suit.

{ 
   doc_count: 0,
   update_seq: 0,
   backend_adapter: 'LevelDOWN',
   db_name: 'my_database',
   auto_compaction: false,
   adapter: 'leveldb' 
}

Informations sur la base de données distante

De la même manière, vous obtenez les informations d'une base de données qui est enregistrée à distance sur le serveur (CouchDB). Pour ce faire, au lieu du nom de la base de données, vous devez transmettre le chemin d'accès à la base de données requise dans CouchDB.

Exemple

Voici un exemple de récupération des informations d'une base de données sauvegardée sur le serveur CouchDB. Ce code vous donne des informations sur une base de données nomméemy_database.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('http://localhost:5984/my_database');

//Database information
db.info(function(err, info) {
   if (err) {
      return console.log(err);
   } else {
      console.log(info);
   }
});

Enregistrez le code ci-dessus dans un fichier avec le nom Database_ Remote_info.js. Ouvrez l'invite de commande et exécutez le fichier JavaScript en utilisantnode comme indiqué ci-dessous.

C:\PouchDB_Examples>node Database_Remote_info.js

Cela affichera les informations de la base de données spécifiée comme suit.

{ 
   db_name: 'my_database', 
   doc_count: 0, 
   doc_del_count: 0, 
   update_seq: 0, 
   purge_seq: 0, 
   compact_running: false, 
   disk_size: 79, 
   data_size: 0, 
   instance_start_time: '1458209191708486', 
   disk_format_version: 6, 
   committed_update_seq: 0, 
   host: 'http://localhost:5984/my_database/', 
   auto_compaction: false, 
   adapter: 'http' 
}

Vous pouvez supprimer une base de données dans PouchDB en utilisant le db.destroy() méthode.

Syntaxe

Voici la syntaxe d'utilisation du db.destroy()méthode. Cette méthode accepte une fonction de rappel en tant que paramètre.

db.destroy()

Exemple

Voici un exemple de suppression d'une base de données dans PouchDB à l'aide du destroy()méthode. Ici, nous supprimons la base de données nomméemy_database, créé dans les chapitres précédents.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//deleting database
db.destroy(function (err, response) {
   if (err) {
      return console.log(err);
   } else {
      console.log ("Database Deleted”);
   }
});

Enregistrez le code ci-dessus dans un fichier avec le nom Delete_Database.js. Ouvrez l'invite de commande et exécutez le fichier JavaScript en utilisant node comme indiqué ci-dessous.

C:\PouchDB_Examples >node Delete_Database.js

Cela supprimera la base de données nommée my_database qui est stocké localement affichant le message suivant.

Database Deleted

Suppression d'une base de données distante

De la même manière, vous pouvez supprimer une base de données stockée à distance sur le serveur (CouchDB).

Pour ce faire, au lieu d'un nom de base de données, vous devez transmettre le chemin vers la base de données qui doit être supprimée, dans CouchDB.

Exemple

Supposons qu'il existe une base de données nommée my_databasedans le serveur CouchDB. Ensuite, si vous vérifiez la liste des bases de données dans CouchDB à l'aide de l'URLhttp://127.0.0.1:5984/_utils/index.html vous obtiendrez la capture d'écran suivante.

Voici un exemple de suppression d'une base de données nommée my_database qui est enregistré sur le serveur CouchDB.

//Requiring the package
var PouchDB = require('pouchdb');

//Creating the database object
var db = new PouchDB('http://localhost:5984/my_database');

//deleting database
db.destroy(function (err, response) {
   if (err) {
      return console.log(err);
   } else {
      console.log("Database Deleted");
   }
});

Enregistrez le code ci-dessus dans un fichier avec le nom Remote_Database_Delete.js. Ouvrez l'invite de commande et exécutez le fichier JavaScript en utilisantnode comme indiqué ci-dessous.

C:\PouchDB_Examples >Remote_Database_Delete.js

Cela supprime la base de données spécifiée de PouchDB en affichant le message suivant.

Database Deleted

Vérification

Après avoir exécuté le programme ci-dessus, si vous visitez à nouveau l'URL, vous obtiendrez la capture d'écran suivante. Ici, vous ne pouvez observer que deux bases de données depuismy_database A été supprimée.

Vous pouvez créer un document dans PouchDB en utilisant le db.put() méthode.

Syntaxe

Voici la syntaxe d'utilisation de la méthode db.put () de PouchDB. Vous pouvez stocker le document à créer dans PouchDB, dans une variable et le passer en paramètre à cette méthode. En outre, cette méthode accepte également une fonction de rappel (facultative) en tant que paramètre.

db.put(document, callback)

Exemple

Voici un exemple de création d'un document dans PouchDB à l'aide du put()méthode. Le document que nous créons doit être au format JSON, un ensemble de paires clé-valeur séparées par une virgule (,) et entouré d'accolades ({}).

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Preparing the document
doc = {
   _id : '001',
   name: 'Raju',
   age : 23,
   designation : 'Designer'
   }
//Inserting Document
db.put(doc, function(err, response) {
   if (err) {
      return console.log(err);
   } else {
      console.log("Document created Successfully");
   }
});

Enregistrez le code ci-dessus dans un fichier avec un nom Create_Document.js. Ouvrez l'invite de commande et exécutez le fichier JavaScript en utilisantnode comme indiqué ci-dessous.

C:\PouchDB_Examples >node Create_Document.js

Cela crée le document donné dans la base de données PouchDB nommé my_database, qui est stocké localement, affichant le message suivant.

Document created Successfully

Insertion d'un document dans une base de données distante

Vous pouvez également insérer un document dans la base de données qui est stocké à distance sur le serveur (CouchDB).

Pour ce faire, au lieu du nom de la base de données, vous devez transmettre le chemin d'accès à la base de données dans laquelle vous souhaitez créer des documents dans CouchDB.

Exemple

Maintenant, si vous cliquez sur la base de données nommée my_database, vous trouverez une base de données vide comme indiqué dans la capture d'écran suivante.

Voici un exemple d'insertion d'un document dans une base de données nommée my_database qui est enregistré sur le serveur CouchDB.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('http://localhost:5984/my_database');

//Preparing the document
doc = {
   _id : '001',
   name: 'Raju',
   age : 23,
   designation : 'Designer'
   }
//Inserting Document
db.put(doc, function(err, response) {
   if (err) {
      return console.log(err);
   } else {
      console.log("Document created Successfully");
   }
});

Enregistrez le code ci-dessus dans un fichier avec le nom Remote_Create_Document.js. Ouvrez l'invite de commande et exécutez le fichier JavaScript en utilisantnode comme indiqué ci-dessous.

C:\PouchDB_Examples >node Remote_Create_Document.js

Cela crée le document donné dans la base de données PouchDB nommé my_database qui est stocké dans CouchDB, affichant le message suivant.

Document created Successfully

Vérification

Après avoir exécuté le programme ci-dessus, si vous visitez le my_database à nouveau, vous pouvez observer le document créé comme indiqué dans la capture d'écran suivante.

Vous pouvez lire / récupérer le contenu d'un document dans PouchDB en utilisant le db.get() méthode.

Syntaxe

Voici la syntaxe d'utilisation du db.get()méthode de PouchDB. Cette méthode accepte ledocument id et une fonction de rappel facultative.

db.get(document, callback)

Exemple

Voici un exemple de lecture du contenu d'un document dans PouchDB à l'aide du get() méthode.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Reading the contents of a Document
db.get('001', function(err, doc) {
   if (err) {
      return console.log(err);
   } else {
      console.log(doc);
   }
});

Enregistrez le code ci-dessus dans un fichier avec un nom Read_Document.js. Ouvrez l'invite de commande et exécutez le fichier JavaScript à l'aide du nœud comme indiqué ci-dessous.

C:\PouchDB_Examples >node Read_Document.js

Cela lit le contenu du document donné qui existe dans la base de données nommée my_databasequi est stocké localement. Le message suivant s'affiche sur la console.

{
   name: 'Raju',
   age: 23,
   designation: 'Designer',
   _id: '001',
   _rev: '1-ba7f6914ac80098e6f63d2bfb0391637'
}

Lire un document à partir d'une base de données distante

Vous pouvez également lire un document de la base de données qui est stocké à distance sur le serveur (CouchDB).

Pour ce faire, au lieu d'un nom de base de données, vous devez transmettre le chemin d'accès à la base de données dans CouchDB, qui contient le document à lire.

Exemple

En cliquant sur la base de données nommée my_databasevous pouvez voir la capture d'écran suivante. Ici, vous pouvez observer que cette base de données contient un document avec id001.

Voici un exemple de lecture du contenu du document ayant l'identifiant comme "001»Qui existe dans une base de données nommée my_database, qui est stocké sur le serveur CouchDB.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('http://localhost:5984/my_database');

//Reading the contents of a document
db.get('001', function(err, doc) {
   if (err) {
      return console.log(err);
   } else {
      console.log(doc);
   }
});

Enregistrez le code ci-dessus dans un fichier avec le nom Remote_Read_Document.js. Ouvrez l'invite de commande et exécutez le fichier JavaScript en utilisantnode comme indiqué ci-dessous.

C:\PouchDB_Examples >node Remote_Read_Document.js

Cela lit le contenu du document donné qui existe dans la base de données nommée my_databasequi est stocké dans CouchDB. Le message suivant s'affiche sur la console.

{ 
   _id: '001',
   _rev: '3-552920d1ca372986fad7b996ce365f5d',
   name: 'Raju',
   age: 23,
   designation: 'Designer' 
}

Chaque fois que nous créons un document dans PouchDB, un nouveau champ _rev est généré, et il est connu comme revision marker. le_revLa valeur de est un nombre aléatoire unique, chaque fois que nous apportons des modifications au document, la valeur de _rev est changé.

Vous pouvez mettre à jour un document existant dans PouchDB à l'aide du (_rev). Pour ce faire, récupérez tout d'abord le_revvaleur du document que nous voulons mettre à jour. Maintenant, placez le contenu à mettre à jour avec le contenu récupéré_rev valeur dans un nouveau document, et enfin insérer ce document dans PouchDB en utilisant le put() méthode.

Exemple

Supposons que nous ayons un document dans PouchDB avec un identifiant 001qui a des détails sur une personne. Afin de mettre à jour ce document, nous devrions avoir son numéro de rév. Par conséquent, pour récupérer le contenu du document, le code suivant est utilisé.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Reading the contents of a Document
db.get('001', function(err, doc) {
   if (err) {
      return console.log(err);
   } else {
      console.log(doc);
   }
});

Lors de l'exécution du code ci-dessus, vous recevrez la sortie suivante.

{
   _id: '001',
   _rev: '3-552920d1ca372986fad7b996ce365f5d',
   name: 'Raju',
   age: 23,
   designation: 'Designer' 
}

Maintenant, en utilisant le _rev vous pouvez mettre à jour la valeur de la clé "age”À 26, comme indiqué dans le code suivant.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Preparing the document for update
doc = {
   age: 26,
   _rev: '3-552920d1ca372986fad7b996ce365f5d',
   }

//Inserting Document
db.put(doc);

//Reading the contents of a Document
db.get('001', function(err, doc) {
   if (err) {
      return console.log(err);
   } else {
      console.log(doc);
   }
});

Enregistrez le code ci-dessus dans un fichier avec le nom Update_Document.js. Ouvrez l'invite de commande et exécutez le fichier JavaScript en utilisantnode comme indiqué ci-dessous.

C:\Pouch_Examples>node Update_Document.js

Cela met à jour le contenu du document donné qui existe dans la base de données nommée my_databasequi est stocké localement. Le message suivant s'affiche sur la console.

{ 
   name: 'Raju',
   age: 26,
   designation: 'Designer',
   _id: '001',
   _rev: '2-61b523ccdc4e41a8435bdffbb057a7a5' 
}

Mise à jour d'un document dans une base de données distante

Vous pouvez également mettre à jour un document existant dans une base de données stockée à distance sur le serveur (CouchDB).

Pour ce faire, au lieu d'un nom de base de données, vous devez transmettre le chemin d'accès à la base de données dans CouchDB, qui contient le document à mettre à jour.

Exemple

En cliquant sur la base de données nommée my_database, vous pouvez voir la capture d'écran suivante. Ici, vous pouvez observer que cette base de données contient un document avec id001.

Voici un exemple de mise à jour de l'âge du document dont l'identifiant est "001»Qui existe dans une base de données nommée my_database qui est stocké sur le serveur CouchDB.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('http://localhost:5984/my_database');

//Preparing the document for update
doc = {
   age: 26,
   _rev: '3-552920d1ca372986fad7b996ce365f5d',
   }

//Inserting Document
db.put(doc);

//Reading the contents of a Document
db.get('001', function(err, doc) {
   if (err) {
      return console.log(err);
   } else {
      console.log(doc);
   }
});

Enregistrez le code ci-dessus dans un fichier avec le nom Remote_Update_Document.js. Ouvrez l'invite de commande et exécutez le fichier JavaScript en utilisantnode comme indiqué ci-dessous.

C:\PouchDB_Examples >node Remote_Update_Document.js

Cela met à jour le contenu du document donné qui existe dans la base de données nommée my_databasequi est stocké dans CouchDB. Le message suivant s'affiche sur la console.

{
   _id: '001',
   _rev: '2-b9640bffbce582c94308905eed8bb545',
   name: 'Raju',
   age: 26,
   designation: 'Designer' 
}

Vous pouvez supprimer un document d'une base de données qui existe dans PouchDB en utilisant le db.remove() méthode.

Syntaxe

Voici la syntaxe d'utilisation du db.remove()méthode de PouchDB. A cette méthode, il faut passerid et _revpour supprimer un document existant comme indiqué dans le code suivant. Cette méthode accepte une fonction de rappel facultative. Nous pouvons également transmettre le document complet au lieu de id et _rev.

db. get ( docId, docRev, [callback] )
or
db. get ( docId, docRev, [callback] )

Exemple

Supposons que nous ayons un document dans PouchDB avec un identifiant 001qui ont les détails d'une personne. Afin de supprimer ce document avec sonid nous devrions aussi avoir son _revnombre. Par conséquent, récupérez le contenu du document comme indiqué dans le code suivant.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Reading the contents of a Document
db.get('001', function(err, doc) {
   if (err) {
      return console.log(err);
   } else {
      console.log(doc);
   }
});

L'exécution du code ci-dessus donne la sortie suivante.

{
   _id: '001',
   _rev: '3-552920d1ca372986fad7b996ce365f5d',
   name: 'Raju',
   age: 23,
   designation: 'Designer' 
}

Maintenant, en utilisant le _rev et l'ID du document, vous pouvez le supprimer en utilisant le remove() méthode comme indiqué dans le code suivant.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Deleting an existing document
db.remove('001', '3-552920d1ca372986fad7b996ce365f5d', function(err) {
   if (err) {
      return console.log(err);
   } else {
      console.log("Document deleted successfully");
   }
});

Enregistrez le code ci-dessus dans un fichier avec le nom Delete_Document.js. Ouvrez l'invite de commande et exécutez le fichier JavaScript en utilisantnode comme indiqué ci-dessous.

C:\PouchDB_Examples >node Delete_Document.js

Cela supprime le contenu du document donné qui existe dans la base de données nommée my_databasequi est stocké localement. Le message suivant s'affiche.

Document deleted successfully

Suppression d'un document d'une base de données distante

Vous pouvez également supprimer un document existant de la base de données stockée à distance sur le serveur (CouchDB).

Pour ce faire, au lieu d'un nom de base de données, vous devez transmettre le chemin d'accès à la base de données dans CouchDB, qui contient le document à lire.

Exemple

En cliquant sur la base de données nommée my_databasevous pouvez voir la capture d'écran suivante. Ici, vous pouvez observer que la base de données contient un document avec id001.

Voici un exemple de suppression du contenu du document ayant l'identifiant "001»Qui existe dans une base de données nommée my_database qui est stocké sur le serveur CouchDB.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('http://localhost:5984/my_database');

//Deleting an existing document
db.remove('001', '3-552920d1ca372986fad7b996ce365f5d', function(err) {
   if (err) {
      return console.log(err);
   } else {
      console.log("Document deleted successfully");
   }
});

Enregistrez le code ci-dessus dans un fichier avec un nom Remote_Delete_Document.js. Ouvrez l'invite de commande et exécutez le fichier JavaScript en utilisantnode comme indiqué ci-dessous.

C:\PouchDB_Examples >node Remote_Delete_Document.js

Cela supprime le document donné qui existe dans la base de données nommée my_databasequi est stocké dans CouchDB. Le message suivant s'affiche.

Document deleted successfully

Vous pouvez créer un tableau (lot) de documents dans PouchDB en utilisant le db.bulkDocs()méthode. Lors de la création de documents, en utilisant cette méthode si nous ne fournissons pas de valeurs _id, PouchDB génère en notre nom des identifiants uniques pour tous les documents en masse.

Syntaxe

Voici la syntaxe d'utilisation du db.bulkDocs()méthode de PouchDB. Vous pouvez stocker tous les documents à créer dans PouchDB dans un tableau et le transmettre à cette méthode en tant que paramètre. En plus de cela, cette méthode accepte également une fonction de rappel (facultative) en tant que paramètre.

db.bulkDocs(docs, [options], [callback])

Exemple

Voici un exemple de création de plusieurs documents dans PouchDB à l'aide du db.bulkDocs ()méthode. Les documents que nous créons doivent être au format JSON, un ensemble de paires clé-valeur séparées par une virgule (,) et entouré d'accolades ({}).

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Preparing the documents array
doc1 = {_id: '001', name: 'Ram', age: 23, Designation: 'Programmer'}
doc2 = {_id: '002', name: 'Robert', age: 24, Designation: 'Programmer'}
doc3 = {_id: '003', name: 'Rahim', age: 25, Designation: 'Programmer'}
docs = [doc1, doc2, doc3]

//Inserting Documents
db.bulkDocs(docs, function(err, response) {
   if (err) {
      return console.log(err);
   } else {
      console.log("Documents created Successfully");
   }
});

Enregistrez le code ci-dessus dans un fichier avec un nom Create_Batch.js. Ouvrez l'invite de commande et exécutez le fichier JavaScript en utilisantnode comme indiqué ci-dessous.

C:\PouchDB_Examples >node Create_Batch.js

Cela crée le document donné dans la base de données PouchDB nommé my_databasequi est stocké localement. Le message suivant s'affiche.

Documents created Successfully

Insertion d'un lot dans une base de données distante

Vous pouvez insérer un tableau de documents dans la base de données qui est stocké à distance sur le serveur (CouchDB).

Pour ce faire, au lieu d'un nom de base de données, vous devez passer le chemin vers la base de données dans laquelle nous voulons créer des documents dans CouchDB.

Exemple

Voici un exemple d'insertion d'un tableau de documents dans la base de données nommé my_database qui est sauvegardé sur le serveur CouchDB.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('http://localhost:5984/my_database');

//Preparing the documents array

doc1 = {_id: '001', name: 'Ram', age: 23, Designation: 'Programmer'}
doc2 = {_id: '002', name: 'Robert', age: 24, Designation: 'Programmer'}
doc3 = {_id: '003', name: 'Rahim', age: 25, Designation: 'Programmer'}

docs = [doc1, doc2, doc3]

//Inserting Documents
db.bulkDocs(docs, function(err, response) {
   if (err) {
      return console.log(err);
   } else {
      console.log("Documents created Successfully");
   }
});

Enregistrez le code ci-dessus dans un fichier avec le nom Remote_Create_Batch.js. Ouvrez l'invite de commande et exécutez le fichier JavaScript en utilisantnode comme indiqué ci-dessous.

C:\PouchDB_Examples >node Remote_Create_Batch.js

Cela crée les documents donnés dans la base de données PouchDB nommés my_databasequi est stocké dans CouchDB. Le message suivant s'affiche.

Document created Successfully

Vérification

Après avoir exécuté le programme ci-dessus si vous visitez le my_database encore une fois, vous pouvez observer les documents créés comme indiqué dans la capture d'écran suivante.

Vous pouvez lire / récupérer plusieurs documents / en bloc à partir d'une base de données dans PouchDB en utilisant le allDocs() méthode.

Syntaxe

Voici la syntaxe d'utilisation du db.allDocs()méthode de PouchDB. Cette méthode accepte une fonction de rappel facultative.

db.allDocs()

Exemple

Voici un exemple de récupération de tous les documents dans une base de données nommée my_database qui est stocké localement, en utilisant db.allDocs()méthode. Cette méthode récupère le tableau de documents sous forme d'objets, pour obtenir le contenu de chaque document que vous devez appeler commedocs.rows.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Retrieving all the documents in PouchDB
db.allDocs(function(err, docs) {
   if (err) {
      return console.log(err);
   } else {
      console.log (docs.rows);
   }
});

Enregistrez le code ci-dessus dans un fichier avec le nom Read_All_Document.js. Ouvrez l'invite de commande et exécutez le fichier JavaScript en utilisantnode comme indiqué ci-dessous.

C:\PouchDB_Examples >node Read_All_Document.js

Cela lit tous les documents qui existent dans la base de données nommée my_databasequi est stocké localement. Le message suivant s'affiche sur la console.

[ 
   { 
      id: '001',
      key: '001',
      value: { rev: '1-9dc57f5faa7ea90eeec22eba8bfd05f5' } 
   },
   { 
      id: '002',
      key: '002',
      value: { rev: '1-9bf80afcedb9f8b5b35567292affb254' } 
    },
   { 
      id: '003',
      key: '003',
      value: { rev: '1-1204f108e41bf8baf867856d5da16c57' } 
   }
]

En général, comme indiqué dans le résultat ci-dessus, en utilisant allDocs() méthode, vous ne pouvez voir que le _id, key et _revchamps de chaque document. Cependant, pour inclure l'ensemble du document dans le résultat, vous devez définir le paramètre facultatifinclude_docs vrai comme indiqué ci-dessous.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Retrieving all the documents in PouchDB
db.allDocs({include_docs: true}, function(err, docs) {
   if (err) {
      return console.log(err);
   } else {
      console.log (docs.rows);
   }
});

L'exécution du code ci-dessus vous donne une liste de documents complets dans les documents spécifiés, comme indiqué dans le code suivant.

[ 
   { 
      id: '001',
      key: '001',
      value: { rev: '1-9dc57f5faa7ea90eeec22eba8bfd05f5' },
      doc: { 
         name: 'Ram',
         age: 23,
         Designation: 'Programmer',
         _id: '001',
         _rev: '1-9dc57f5faa7ea90eeec22eba8bfd05f5' 
      } 
   },
   { 
      id: '002',
      key: '002',
      value: { rev: '1-9bf80afcedb9f8b5b35567292affb254' },
      doc: { 
         name: 'Robert',
         age: 24,
         Designation: 'Programmer',
         _id: '002',
         _rev: '1-9bf80afcedb9f8b5b35567292affb254' 
      } 
   },
   { 
      id: '003',
      key: '003',
      value: { rev: '1-1204f108e41bf8baf867856d5da16c57' },
      doc: { 
         name: 'Rahim',
         age: 25,
         Designation: 'Programmer',
         _id: '003',
         _rev: '1-1204f108e41bf8baf867856d5da16c57' 
      } 
   }
]

Lire un lot à partir d'une base de données distante

Vous pouvez également récupérer tous les documents de la base de données qui est stockée à distance sur le serveur (CouchDB).

Pour ce faire, au lieu d'un nom de base de données, vous devez transmettre le chemin d'accès à la base de données dans CouchDB, qui contient le document à lire.

Exemple

Voici un exemple de lecture de tous les documents qui existent dans une base de données nommée my_database qui est stocké sur le serveur CouchDB.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('http://localhost:5984/my_database');

//Retrieving all the documents in PouchDB
db.allDocs({include_docs: true}, function(err, docs) {
   if (err) {
      return console.log(err);
   } else {
      console.log(docs.rows);
   }
});

Enregistrez le code ci-dessus dans un fichier avec le nom Remote_Read_AllDocument.js. Ouvrez l'invite de commande et exécutez le fichier JavaScript en utilisantnode comme indiqué ci-dessous.

C:\PouchDB_Examples >node Remote_Read_AllDocument.js

Cela lit le contenu du document donné qui existe dans la base de données nommée my_database qui est stocké dans CouchDB et s'affiche sur la console comme illustré ci-dessous.

[ 
   { 
      id: '001',
      key: '001',
      value: { rev: '3-552920d1ca372986fad7b996ce365f5d' },
      doc: { 
         _id: '001',
         _rev: '3-552920d1ca372986fad7b996ce365f5d',
         name: 'Raju',
         age: 23,
         designation: 'Designer' 
      } 
   },
   { 
      id: '002',
      key: '002',
      value: { rev: '1-9af15cb11054ebe03a7816bf6c5e4128' },
      doc: { 
         _id: '002',
         _rev: '1-9af15cb11054ebe03a7816bf6c5e4128',
         name: 'Robert',
         age: 24,
         Designation: 'Programmer' 
      } 
   },
   { 
      id: '003',
      key: '003',
      value: { rev: '1-3033b5a78e915c52fd37325d42eb3935' },
      doc: { 
         _id: '003',
         _rev: '1-3033b5a78e915c52fd37325d42eb3935',
         name: 'Rahim',
         age: 25,
         Designation: 'Programmer' 
      } 
   } 
]

Vous pouvez mettre à jour un tableau de documents dans PouchDB à la fois en utilisant le bulkDocs()méthode. Pour ce faire, vous devez créer un tableau de documents où, chaque document contient_id, _rev et les valeurs à mettre à jour.

Supposons que la base de données nommée my_database qui est stocké localement dans PouchDB contient 3 documents à savoir doc1, doc2, doc3 avec le contenu suivant.

doc1 = {_id: '001', name: 'Ram', age: 23, Designation: 'Programmer'}
doc2 = {_id: '002', name: 'Robert', age: 24, Designation: 'Programmer'}
doc3 = {_id: '003', name: 'Rahim', age: 25, Designation: 'Programmer'}

Supposons que nous devions augmenter les valeurs d'âge des 3 documents de 2 ans. Pour que cela se produise, vous devez d'abord obtenir le_revvaleurs. Par conséquent, récupérez le contenu de ces documents à l'aide du code suivant.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Retrieving all the documents in PouchDB
db.allDocs({include_docs: true},function(err, docs) {
   if (err) {
      return console.log(err);
   } else {
      console.log(docs.rows);
   }
});

Enregistrez le code ci-dessus sous bulk_fetch.js. Lors de l'exécution, le programme ci-dessus vous donne les valeurs _id et _rev des documents de la base de données comme indiqué ci-dessous.

[ 
   { 
      id: '001',
      key: '001',
      value: { rev: '1-1604b0c3ff69dc1e261265fd60808404' } 
   },
   { 
      id: '002',
      key: '002',
      value: { rev: '1-b5e49db7e984841bf12a13e3ee548125' } 
   },
   { 
      id: '003',
      key: '003',
      value: { rev: '1-a7b342786ecc707aa91f3b321a177b51' } 
   } 
]

Désormais, vous pouvez mettre à jour les documents en utilisant leurs _id et _rev valeurs comme indiqué ci-dessous.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_databas');

//Preparing the document
docs = [{_id : '001', _rev: '1-1604b0c3ff69dc1e261265fd60808404', age : 25, },
      {_id : '002', _rev: '1-b5e49db7e984841bf12a13e3ee548125', age : 26, },
      {_id : '003', _rev: '1-a7b342786ecc707aa91f3b321a177b51', age : 27 }]

//Updating the documents in bulk
db.bulkDocs(docs, function(err, response) {
   if (err) {
      return console.log(err);
   } else {
      console.log("Documents Updated Successfully");
   }
});

Enregistrez le code ci-dessus dans un fichier avec le nom Update_All_Document.js. Ouvrez l'invite de commande et exécutez le fichier JavaScript à l'aide du nœud comme indiqué ci-dessous.

C:\PouchDB_Examples >node Update_All_Document.js

Cela met à jour tous les documents qui existent dans la base de données nommée my_database qui est stocké localement, affichant le message suivant.

Documents Updated Successfully

Maintenant, si vous exécutez le bulk_fetch.js programme en ajoutant {include_docs: true} comme paramètre de allDocs() fonction, avant le rappel, vous pourrez alors voir les valeurs des documents mis à jour, comme indiqué ci-dessous.

[ 
   { 
      id: '001',
      key: '001',
      value: { rev: '2-77f3a9974dd578d12f3f2a33aae64c8d' },
      doc: { 
         age: 25,
         _id: '001',
         _rev: '2-77f3a9974dd578d12f3f2a33aae64c8d' 
      } 
   },
   { 
      id: '002',
      key: '002',
      value: { rev: '2-43966007568ce9567c96422195fcfa0d' },
      doc: { 
         age: 26,
         _id: '002',
         _rev: '2-43966007568ce9567c96422195fcfa0d' 
      } 
   },
   { 
      id: '003',
      key: '003',
      value: { rev: '2-6c5349652527f4f39583ff14f23cd677' },
      doc: { 
         age: 27,
         _id: '003',
         _rev: '2-6c5349652527f4f39583ff14f23cd677' 
      } 
   } 
]

Mise à jour d'un lot à partir d'une base de données distante

Vous pouvez mettre à jour tous les documents de la base de données stockée à distance sur le serveur (CouchDB).

Pour ce faire, au lieu d'un nom de base de données, vous devez transmettre le chemin d'accès à la base de données dans CouchDB, qui contient le document à lire.

Exemple

Et supposons que si nous sélectionnons la base de données nommée my_database, vous pouvez observer qu'il contient 3 documents comme le montre la capture d'écran suivante.

Maintenant, récupérez le contenu de ces documents en utilisant le code suivant.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('http://localhost:5984/my_database');

//Retrieving all the documents in PouchDB
db.allDocs({include_docs: true}, function(err, docs) {
   if (err) {
      return console.log(err);
   } else {
      console.log(docs.rows);
   }
});

Enregistrez le code ci-dessus sous remote_bulk_fetch.js. Lors de l'exécution, le programme ci-dessus vous donne le contenu de tous les documents de la base de données comme indiqué ci-dessous.

[ 
   { 
      id: '001', 
      key: '001', 
      value: { rev: '3-552920d1ca372986fad7b996ce365f5d' }, 
      doc: { 
         _id: '001', 
         _rev: '3-552920d1ca372986fad7b996ce365f5d', 
         name: 'Raju', 
         age: 23, 
         designation: 'Designer' 
      } 
   },
   { 
      id: '002', 
      key: '002', 
      value: { rev: '1-9af15cb11054ebe03a7816bf6c5e4128' }, 
      doc: { 
         _id: '002', 
         _rev: '1-9af15cb11054ebe03a7816bf6c5e4128', 
         name: 'Robert', 
         age: 24, 
         Designation: 'Programmer' 
      } 
   }, 
   { 
      id: '003', 
      key: '003', 
      value: { rev: '1-3033b5a78e915c52fd37325d42eb3935' }, 
      doc: { 
         _id: '003',
         _rev: '1-3033b5a78e915c52fd37325d42eb3935',
         name: 'Rahim', 
         age: 25, 
         Designation: 'Programmer' 
      } 
   } 
]

Voici un exemple de mise à jour de tous les documents qui existent dans une base de données nommée my_database qui est stocké sur le serveur CouchDB.

//Requiring the package 
var PouchDB = require('PouchDB');

//Creating the database object 
var db = new PouchDB('http://localhost:5984/my_database'); 

//Preparing the document 
docs = [{_id : '001', _rev: '3-552920d1ca372986fad7b996ce365f5d', age : 24, }, 
      {_id : '002', _rev: '1-9af15cb11054ebe03a7816bf6c5e4128', age : 26, }, 
      {_id : '003', _rev: '1-3033b5a78e915c52fd37325d42eb3935', age : 27}]

//Inserting Document 
db.bulkDocs(docs, function(err, response) { 
   if (err) { 
      return console.log(err); 
   } else { 
      console.log(+"Documents Updated Successfully"); 
   } 
});

Enregistrez le code ci-dessus dans un fichier avec le nom Remote_Update_Document.js. Ouvrez l'invite de commande et exécutez le fichier JavaScript à l'aide du nœud comme indiqué ci-dessous.

C:\PouchDB_Examples >node Remote_Update_Document.js

Cela met à jour le contenu de tous les documents donnés qui existent dans la base de données nommée my_database qui est stocké dans CouchDB et affiche le message suivant.

Documents Updated Successfully

Maintenant, si vous exécutez le remote_bulk_fetch.js programme, vous pourrez voir les valeurs des documents mis à jour, comme indiqué ci-dessous.

[ 
   { 
      id: '001',
      key: '001',
      value: { rev: '4-6bc8d9c7a60fed2ed1667ec0740c1f39' },
      doc: { 
         _id: '001',
         _rev: '4-6bc8d9c7a60fed2ed1667ec0740c1f39',
         age: 25 
      } 
   },
   { 
      id: '002',
      key: '002',
      value: { rev: '2-1aa24ce77d96bb9d2a0675cdf1e113e0' },
      doc: { 
         _id: '002',
         _rev: '2-1aa24ce77d96bb9d2a0675cdf1e113e0',
         age: 26 
      } 
   },
   { 
      id: '003',
      key: '003',
      value: { rev: '2-fa113149ba618eda77f73072974a2bc1' },
      doc: { 
         _id: '003',
         _rev: '2-fa113149ba618eda77f73072974a2bc1',
         age: 27 
      } 
   } 
]

Vous pouvez supprimer un tableau de documents dans PouchDB à la fois en utilisant le bulkDocs()méthode. Pour ce faire, vous devez créer un tableau de documents qui doivent être supprimés où, chaque document doit contenir_id et _rev. En plus de ceux-ci, vous devez ajouter une autre paire clé-valeur_deleted: true.

Supposons que la base de données nommée my_database qui est stocké localement dans PouchDB contient 3 documents à savoir doc1, doc2, doc3 avec le contenu suivant.

doc1 = {_id: '001', name: 'Ram', age: 23, Designation: 'Programmer'}
doc2 = {_id: '002', name: 'Robert', age: 24, Designation: 'Programmer'}
doc3 = {_id: '003', name: 'Rahim', age: 25, Designation: 'Programmer'}

Et disons, nous devons supprimer les trois documents. Ensuite, tout d'abord, vous devez obtenir leur_revvaleurs. Par conséquent, récupérez le contenu de ces documents à l'aide du code suivant.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Retrieving all the documents in PouchDB
db.allDocs({include_docs: true},function(err, docs) {
   if (err) {
      return console.log(err);
   } else {
      console.log(docs.rows);
   }
});

Enregistrez le code ci-dessus sous bulk_fetch.js. L'exécution du programme ci-dessus vous donne les valeurs _id et _rev des documents de la base de données comme indiqué ci-dessous.

[ 
   { 
      id: '001',
      key: '001',
      value: { rev: '1-1604b0c3ff69dc1e261265fd60808404' } 
   },
   { 
      id: '002',
      key: '002',
      value: { rev: '1-b5e49db7e984841bf12a13e3ee548125' } 
   },
   { 
      id: '003',
      key: '003',
      value: { rev: '1-a7b342786ecc707aa91f3b321a177b51' } 
   } 
]

Maintenant, vous pouvez supprimer les documents en utilisant leurs _id et _rev valeurs comme indiqué ci-dessous.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Preparing the document
docs = [{_id : '001', _rev: '2-77f3a9974dd578d12f3f2a33aae64c8d', _deleted : true },
      {_id : '002', _rev: '2-43966007568ce9567c96422195fcfa0d', _deleted : true }, 
      {_id : '003', _rev: '2-6c5349652527f4f39583ff14f23cd677',_deleted : true }]

//Deleting Documents
db.bulkDocs(docs, function(err, response) {
   if (err) {
      return console.log(err);
   } else {
      console.log(response+"Documents deleted Successfully");
   }
});

Enregistrez le code ci-dessus dans un fichier avec le nom Delete_All_Document.js. Ouvrez l'invite de commande et exécutez le fichier JavaScript à l'aide du nœud comme indiqué ci-dessous.

C:\PouchDB_Examples >node Delete_All_Document.js

Cela supprime tous les documents qui existent dans la base de données nommée my_database qui est stocké localement, affichant le message suivant.

Documents Deleted Successfully

Maintenant, si vous exécutez le bulk_fetch.js programme, vous pouvez observer une accolade vide sur la console indiquant que la base de données est vide, comme indiqué ci-dessous.

[]

Suppression d'un lot d'une base de données distante

Vous pouvez mettre à jour tous les documents de la base de données stockée à distance sur le serveur (CouchDB).

Pour ce faire, au lieu d'un nom de base de données, vous devez transmettre le chemin d'accès à la base de données dans CouchDB, qui contient le document à lire.

Exemple

Si nous sélectionnons la base de données nommée my_database, vous pouvez observer qu'il contient 3 documents comme le montre la capture d'écran suivante.

Voici un exemple de suppression de tous les documents qui existent dans une base de données nommée my_database qui est stocké sur le serveur CouchDB.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('http://localhost:5984/my_database');

//Preparing the document
docs = [{_id : '001', _rev: '4-6bc8d9c7a60fed2ed1667ec0740c1f39', _deleted : true },
      {_id : '002', _rev: '2-1aa24ce77d96bb9d2a0675cdf1e113e0', _deleted : true },
      {_id : '003', _rev: '2-fa113149ba618eda77f73072974a2bc1',_deleted : true }]

//Deleting Documents
db.bulkDocs(docs, function(err, response) {
   if (err) {
      return console.log(err);
   } else {
      console.log("Documents deleted Successfully");
   }
});

Enregistrez le code ci-dessus dans un fichier avec un nom Remote_delete_AllDocuments.js. Ouvrez l'invite de commande et exécutez le fichier JavaScript à l'aide du nœud comme indiqué ci-dessous.

C:\PouchDB_Examples >node Remote_Delete_AllDocuments.js

Cela supprime le contenu de tous les documents donnés qui existent dans la base de données nommée my_database qui est stocké dans CouchDB et affiche le message suivant.

Documents Deleted Successfully

Vous pouvez attacher un objet binaire à un document en utilisant le putAttachment() méthode dans PouchDB.

Syntaxe

Voici la syntaxe du putAttachment(). Pour cette méthode, nous devons transmettre l'identifiant du document, l'identifiant de la pièce jointe, le type MIME avec la pièce jointe. Cette méthode accepte également une fonction de rappel facultative.

db.putAttachment( docId, attachmentId, attachment, type, [callback] );

Nous pouvons préparer la pièce jointe en utilisant des objets blob ou tampon, où blob est utilisé lors de l'utilisation du navigateur et buffer est utilisé lorsque vous travaillez avec Node.js, puisque nous présentons nos programmes dans Node.js, nous utilisons des objets tampons pour préparer les documents.

Exemple

Voici un exemple de création d'un document avec une pièce jointe, dans une base de données nommée my_database dans PouchDB en utilisant putAttachment() méthode.

//Requiring the package 
var PouchDB = require('PouchDB');

//Creating the database object var db = new PouchDB('my_database');

//Preparing the attachment 
var my_attachment = new Buffer(['Welcome to tutorialspoint'], {type: 'text/plain'});

//Adding attachment to a document 
db.putAttachment('001', 'att_1.txt', my_attachment, 'text/plain', function(err, res) { 
   if (err) { 
      return console.log(err); 
   } else { 
      console.log(res+"Attachment added successfully") 
   } 
});

Enregistrez le code ci-dessus dans un fichier avec un nom Add_Attachment.js. Ouvrez l'invite de commande et exécutez le fichier JavaScript en utilisantnode comme indiqué ci-dessous.

C:\PouchDB_Examples >node Add_Attachment.js

Cela crée un document vide en y ajoutant une pièce jointe, dans la base de données nommée my_database stocké dans PouchDB et affiche le message suivant.

Attachment added successfully

Vous pouvez vérifier si la pièce jointe est ajoutée en lisant le document à l'aide du code suivant.

//Requiring the package 
var PouchDB = require('PouchDB');

//Creating the database object var db = new PouchDB('my_database');

//Reading the Document 
db.get('001',{attachments: true}, function(err, doc) { 
   if (err) { 
      return console.log(err); 
   } else { 
      console.log(doc); 
   } 
});

Enregistrez le code ci-dessus sous read_doc.jset exécutez-le. En exécutant ce programme, vous pouvez voir le contenu suivant du document.

{ 
   _attachments: { 
      att_1.txt: { 
         content_type: 'text/plain',
         digest: 'md5-k7iFrf4NoInN9jSQT9WfcQ==',
         data: 'AA==' 
      } 
   },
   _id: '001',
   _rev: '1-620fd5f41d3328fcbf9ce7504338a51d' 
}

Ajouter une pièce jointe à un document existant

Supposons qu'il y ait un document dans une base de données du nom my_database PouchDB avec id '002». Vous pouvez en obtenir le contenu en exécutant leread_doc.js en changeant la valeur id en 002, comme indiqué ci-dessous.

{ 
   name: 'Raju',
   age: 23,
   designation: 'Designer',
   _id: '002',
   _rev: '1-05ca7b5f3f4762a9fb2d119cd34c8d40' 
}

Maintenant, vous pouvez ajouter une pièce jointe à ce document en utilisant son _rev valeur.

//Requiring the package 
var PouchDB = require('PouchDB');

//Creating the database object var db = new PouchDB('my_database');

//Adding attachment to existing document 
var my_attachment = new Buffer (['Welcome to tutorialspoint'], {type: 'text/plain'});

rev = '1-05ca7b5f3f4762a9fb2d119cd34c8d40'; 
db.putAttachment('002', 'att_1.txt', rev, my_attachment, 'text/plain', function(err, res) { 
   if (err) { 
      return console.log(err); 
   } else { 
      console.log (res + "Attachment added successfully") 
   } 
});

Enregistrez le code ci-dessus dans un fichier avec le nom Add_Attachment_to_doc.js. Ouvrez l'invite de commande et exécutez le fichier JavaScript en utilisantnode comme indiqué ci-dessous.

C:\PouchDB_Examples >node Add_Attachment_to_doc.js

Cela ajoute une pièce jointe au document spécifié affichant le message suivant.

Attachment added successfully

Si vous modifiez la valeur de l'identifiant dans read_doc.js à 002 et exécutez-le, vous obtiendrez la sortie suivante.

{ 
   name: 'Raju',
   age: 23,
   designation: 'Designer',
   _attachments: { 
      att_1: { 
         content_type: 'text/plain',
         digest: 'md5-k7iFrf4NoInN9jSQT9WfcQ==',
         data: 'AA==' 
      } 
   },
   _id: '002',
   _rev: '2-3bb4891b954699bce28346723cc7a709' 
}

Ajout d'une pièce jointe à un document distant

Vous pouvez même ajouter une pièce jointe au document existant dans une base de données stockée à distance sur le serveur (CouchDB).

Pour ce faire, au lieu d'un nom de base de données, vous devez transmettre le chemin d'accès à la base de données dans CouchDB, qui contient le document à lire.

Exemple

Et si vous sélectionnez la base de données nommée my_database, vous pouvez afficher son contenu comme indiqué ci-dessous.

Voici un exemple d'ajout d'une pièce jointe au document 001 stocké dans une base de données nommée my_database qui est stocké sur le serveur CouchDB.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('http://localhost:5984/my_database');

//Adding attachment to existing document
var my_attachment = new Buffer (['Welcome to tutorialspoint'], {type: 'text/plain'});

rev = '1-36c34fdcf29a652876219065f9681602';
db.putAttachment('001', 'att_1.txt',rev, my_attachment, 'text/plain', function(err, res) {
   if (err) {
      return console.log(err);
   } else {
      console.log (res+ "Attachment added successfully")
   }
});

Enregistrez le code ci-dessus dans un fichier avec le nom Remote_Add_Attachment.js. Ouvrez l'invite de commande et exécutez le fichier JavaScript en utilisantnode comme indiqué ci-dessous.

C:\PouchDB_Examples >node Remote_Add_Attachment.js

Cela ajoute une pièce jointe au document spécifié affichant le message suivant.

Attachment added successfully

Maintenant, si vous vérifiez le document, vous pouvez observer la pièce jointe qui y est ajoutée, comme illustré dans la capture d'écran suivante.

Vous pouvez récupérer une pièce jointe de PouchDB à l'aide du getAttachment()méthode. Cette méthode retourne toujours des objets blob ou buffer.

Syntaxe

Voici la syntaxe du getAttachment(). Pour cette méthode, nous devons transmettre l'identifiant du document et l'identifiant de la pièce jointe. Cette méthode accepte également une fonction de rappel facultative.

db.getAttachment( docId, attachmentId, [callback] );

Exemple

Voici un exemple de récupération d'une pièce jointe d'un document stocké dans PouchDB, en utilisant getAttachment()méthode. En utilisant ce code, nous essayons de récupérer une pièce jointeatt_1.txt du document 001.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Retrieving an attachment from a document
db.getAttachment('001', 'att_1.txt', function(err, blob_buffer) {
   if (err) {
      return console.log(err);
   } else {
      console.log(blob_buffer);
   }
});

Enregistrez le code ci-dessus dans un fichier avec le nom Retrieve_Attachment.js. Ouvrez l'invite de commande et exécutez le fichier JavaScript en utilisantnode comme indiqué ci-dessous.

C:\PouchDB_Examples >node Retrieve_Attachment.js

Cela récupère la pièce jointe du document et s'affiche sur la console comme indiqué ci-dessous.

<Buffer 00>

Récupération d'une pièce jointe à partir d'un document distant

Vous pouvez également récupérer une pièce jointe d'un document existant dans la base de données qui est stockée à distance sur le serveur (CouchDB).

Pour ce faire, au lieu d'un nom de base de données, vous devez transmettre le chemin d'accès à la base de données dans CouchDB, qui contient le document à lire.

Exemple

Si vous sélectionnez la base de données nommée my_database, vous pouvez afficher son contenu comme indiqué ci-dessous.

Supposons qu'il y ait une pièce jointe dans ce document comme indiqué ci-dessous.

Voici un exemple de récupération d'une pièce jointe du document 001 qui existe dans une base de données nommée my_database, qui est stocké sur le serveur CouchDB.

//Requiring the package 
var PouchDB = require('PouchDB');

//Creating the database object 
var db = new PouchDB('http://localhost:5984/my_database');

//Retrieving an attachment from a document 
db.getAttachment('001', 'att_1.txt', function(err, blob_buffer) { 
   if (err) { 
      return console.log(err); 
   } else { 
      console.log(blob_buffer); 
   } 
});

Enregistrez le code ci-dessus dans un fichier avec le nom Remote_Retrieve_Attachment.js. Ouvrez l'invite de commande et exécutez le fichier JavaScript en utilisantnode comme indiqué ci-dessous.

C:\PouchDB_Examples >node Remote_Retrieve_Attachment.js

Cela récupère la pièce jointe au document et l'affiche sur la console comme indiqué ci-dessous.

<Buffer 00>

Vous pouvez supprimer une pièce jointe de PouchDB à l'aide du removeAttachment() méthode.

Syntaxe

Voici la syntaxe du removeAttachment()méthode. À cette méthode, nous devons transmettre l'ID du document, l'ID de la pièce jointe et la valeur _rev. Cette méthode accepte également une fonction de rappel facultative.

db.removeAttachment ( docId, attachmentId, rev, [callback] );

Exemple

Supposons qu'il y ait un document dans PouchDB avec id 001, qui contient l'identifiant, le nom, l'âge, la désignation d'un employé avec une pièce jointe comme indiqué ci-dessous.

{ 
   name: 'Raju',
   age: 23,
   designation: 'Designer',
   _attachments: { 
      'att_1.txt': { 
         content_type: 'text/plain',
         digest: 'md5-k7iFrf4NoInN9jSQT9WfcQ==',
         data: 'AA==' 
      } 
   },
   _id: '001',
   _rev: '2-cdec6c9f45ddbee7d456945654742d43' 
}

Voici un exemple de suppression de la pièce jointe de ce document 001 stocké dans PouchDB, en utilisant removeAttachment() méthode.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my');
db.removeAttachment('001', 'att_1.txt', '2-cdec6c9f45ddbee7d456945654742d43', 
   function(err, res) {
   if (err) {
      return console.log(err);
   } else {
      console.log(res+"Attachment Deleted successfully")
   }
});

Enregistrez le code ci-dessus dans un fichier avec le nom Remove_Attachment.js. Ouvrez l'invite de commande et exécutez le fichier JavaScript en utilisantnode comme indiqué ci-dessous.

C:\PouchDB_Examples >node Remove_Attachment.js

Cela supprime la pièce jointe du document et affiche un message sur la console comme indiqué ci-dessous.

Attachment deleted successfully

Après la suppression, vous pouvez vérifier le contenu du document en exécutant le code suivant.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_d');

//Reading the Document
db.get('001',{attachments: true}, function(err, doc) {
   if (err) {
      return console.log(err);
   } else {
      console.log(doc);
   }
});

Enregistrez ce code sous read.jset exécutez-le. Lors de l'exécution, vous obtiendrez le contenu du document après avoir supprimé la pièce jointe, comme indiqué ci-dessous.

{ 
   name: 'Raju',
   age: 23,
   designation: 'Designer',
   _id: '001',
   _rev: '3-da775487a6ed0495f2e49c543384f8e8' 
}

Suppression de la pièce jointe d'un document distant

Vous pouvez supprimer une pièce jointe d'un document existant dans la base de données qui est stockée à distance sur le serveur (CouchDB).

Pour ce faire, au lieu d'un nom de base de données, vous devez transmettre le chemin d'accès à la base de données dans CouchDB, qui contient le document à lire.

Exemple

Et si vous sélectionnez la base de données nommée my_database, vous pouvez afficher son contenu comme indiqué ci-dessous.

Supposons qu'il y ait une pièce jointe dans ce document comme indiqué ci-dessous.

Voici un exemple de suppression de la pièce jointe mentionnée ci-dessus du document 001 qui existe dans une base de données nommée my_database qui est stocké sur le serveur CouchDB.

//Requiring the package 
var PouchDB = require('PouchDB');

//Creating the database object 
var db = new PouchDB('http://localhost:5984/my_database');

db.removeAttachment('001', 'att_1.txt', '2-049f1c4ffa54576ec0947b65e34de423', 
   function(err, res) { 
   if (err) { 
      return console.log(err); 
   } else { 
      console.log(res+"Attachment Deleted successfully") 
   } 
});

Enregistrez le code ci-dessus dans un fichier avec le nom Remote_Delete_Attachment.js. Ouvrez l'invite de commande et exécutez le fichier JavaScript en utilisantnode comme indiqué ci-dessous.

C:\PouchDB_Examples >node Remote_Delete_Attachment.js

Cela supprime la pièce jointe existante et affiche le message suivant.

Attachment Deleted successfully

Si vous visitez à nouveau le document, vous pouvez remarquer que la pièce jointe a été supprimée comme indiqué dans la capture d'écran suivante.

L'une des fonctionnalités les plus importantes de PouchDB est la réplication, c'est-à-dire que vous pouvez faire une copie d'une base de données. Vous pouvez répliquer une instance PouchDB stockée localement ou une instance CouchDB stockée à distance.

Syntaxe

Voici la syntaxe de réplication d'une base de données dans PouchDB. Ici, une copie dusource databaseest la cible. À cette méthode, vous pouvez passer directement l'emplacement des bases de données source et de destination au format String, ou vous pouvez transmettre des objets les représentant.

PouchDB.replicate(source, target, [options])

La source et les cibles peuvent être des instances PouchDB ou des instances CouchDB.

Répliquer LocalDB vers CouchDB

Supposons qu'il existe une base de données avec le nom sample_database dans PouchDB, et il contient 3 documents doc1, doc2 et doc3, dont le contenu est indiqué ci-dessous.

doc1 = {_id: '001', name: 'Ram', age: 23, Designation: 'Programmer'} 
doc2 = {_id: '002', name: 'Robert', age: 24, Designation: 'Programmer'} 
doc3 = {_id: '003', name: 'Rahim', age: 25, Designation: 'Programmer'}

Voici un exemple qui fait une copie de la base de données nommée sample_database qui est stocké localement dans CouchDB.

//Requiring the package 
var PouchDB = require('PouchDB');

var localdb = 'sample_database';

//Creating remote database object 
var remotedb = 'http://localhost:5984/sample_database';

//Replicating a local database to Remote 
PouchDB.replicate(localDB, remoteDB); 
console.log ("Database replicated successfully");

Enregistrez le code ci-dessus dans un fichier avec un nom Replication_example.js. Ouvrez l'invite de commande et exécutez le fichier JavaScript en utilisantnode comme indiqué ci-dessous.

C:\PouchDB_Examples >node Replication_example.js

Cela crée une copie de la base de données nommée sample_database dans l'instance CouchDB et affiche un message sur la console comme indiqué ci-dessous.

Database replicated successfully

Vous pouvez vérifier si la base de données est répliquée dans votre instance CouchDB en cliquant sur le lien suivant http://127.0.0.1:5984/_utils/index.html.

En cliquant, vous pouvez voir la liste des bases de données dans votre CouchDB. Vous pouvez également observer qu'une copie de la base de donnéessample_database est créé ici.

Si vous sélectionnez la base de données répliquée, vous pouvez afficher son contenu comme indiqué ci-dessous.

Répliquer CouchDB vers PouchDB

Supposons qu'il existe une base de données avec le nom Remote_Database dans CouchDB et il contient 3 documents, doc1, doc2 et doc3, dont le contenu est indiqué ci-dessous.

doc1 = {_id: '001', name: 'Geeta', age: 25, Designation: 'Programmer'}
doc2 = {_id: '002', name: 'Zara Ali', age: 24, Designation: 'Manager'}
doc3 = {_id: '003', name: 'Mary', age: 23, Designation: 'Admin'}

Voici un exemple qui fait une copie de la base de données nommée Remote_Database qui est stocké dans CouchDB dans le stockage local.

//Requiring the package
var PouchDB = require('PouchDB');

var localdb = 'sample_database';

var remotedb = 'http://localhost:5984/sample_database1';

//Replicating a local database to Remote
PouchDB.replicate(remotedb, localdb);
console.log("Database replicated successfully");

Enregistrez le code ci-dessus dans un fichier avec le nom Replication_example2.js. Ouvrez l'invite de commande et exécutez le fichier JavaScript en utilisantnode comme indiqué ci-dessous.

C:\PouchDB_Examples >node Replication_example2.js

Cela fait une copie de la base de données nommée remote_database dans l'instance PouchDB et affiche un message sur la console comme indiqué ci-dessous.

Database replicated successfully

Vous pouvez vérifier si la base de données est répliquée dans votre instance Pouch en exécutant le code suivant.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('remote_database');

//Retrieving all the documents in PouchDB
db.allDocs({include_docs: true, attachments: true}, function(err, docs) {
   if (err) {
      return console.log(err);
   } else {
      console.log(docs.rows);
   }
});

Si la base de données est répliquée lors de l'exécution du code ci-dessus, vous obtiendrez le contenu de la base de données répliquée comme indiqué ci-dessous.

[ 
   { 
      id: '001', 
      key: '001', 
      value: { rev: '1-23cf3767e32a682c247053b16caecedb' }, 
      doc: { 
         name: 'Geeta', 
         age: 25, 
         Designation: 'Programmer', 
         _id: '001',
         _rev: '1-23cf3767e32a682c247053b16caecedb' 
      } 
   }, 
   { 
      id: '002', 
      key: '002', 
      value: { rev: '1-d5bcfafbd4d4fae92fd7fc4fdcaa3a79' }, 
      doc: { 
         name: 'Zara Ali', 
         age: 24, 
         Designation: 'Manager', 
         _id: '002',
         _rev: '1-d5bcfafbd4d4fae92fd7fc4fdcaa3a79' 
      } 
   }, 
   { 
      id: '003', 
      key: '003', 
      value: { rev: '1-c4cce025dbd30d21e40882d41842d5a4' }, 
      doc: { 
         name: 'Mary', 
         age: 23, 
         Designation: 'Admin', 
         _id: '003', 
         _rev: '1-c4cce025dbd30d21e40882d41842d5a4' 
      } 
   } 
]

Vous pouvez synchroniser les bases de données stockées localement dans PouchDB avec celles stockées dans CouchDB. Dans le chapitre précédent, nous avons vu comment répliquer des bases de données à l'aide de PouchDB. Là, nous avons utilisé la méthodePouchDB.replicate(source, destination).

En plus de cela, nous pouvons également répliquer les données, de la base de données locale vers la base de données distante, et de la base de données distante vers la base de données locale en utilisant replicate.to() et replicate.from() méthodes comme indiqué ci-dessous.

//Replicating data from local database to remote database 
localDB.replicate.to(remoteDB);

//Replicating data from remote database to local database 
localDB.replicate.from(remoteDB);

Où, localDB est un objet de base de données stocké localement dans PouchDB et remoteDB est un objet d'une base de données stockée dans CouchDB.

Exemple

Supposons qu'il existe une base de données avec le nom local_database dans PouchDB, et il contient 3 documents, doc1, doc2 et doc3, dont le contenu est indiqué ci-dessous.

doc1 = {_id: '003', name: 'Ram', age: 26, Designation: 'Programmer'} 
doc2 = {_id: '004', name: 'Robert', age: 27, Designation: 'Programmer'} 
doc3 = {_id: '005', name: 'Rahim', age: 28, Designation: 'Programmer'}

Et il y a une base de données avec le nom Remote_Database dans CouchDB et il contient 2 documents doc1, doc2, dont le contenu est indiqué ci-dessous.

doc1 = {_id: '001', name: 'Geeta', age: 25, Designation: 'Programmer'} 
doc2 = {_id: '002', name: 'Zara Ali', age: 24, Designation: 'Manager'}

Voici un exemple de synchronisation de ces deux bases de données, l'une étant stockée dans PouchDB et l'autre stockée dans CouchDB, à l'aide du replicate.to() et replicate.from() méthodes.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating local database object
var localDB = new PouchDB('local_database');

//Creating remote database object
var remoteDB = new PouchDB('http://localhost:5984/remote_database');

//Synchronising both databases
localDB.replicate.to(remoteDB);
remoteDB.replicate.from(localDB);
console.log("Databases synchronized successfully");

Enregistrez le code ci-dessus dans un fichier avec le nom Synchronising_databases.js. Ouvrez l'invite de commande et exécutez le fichier JavaScript en utilisantnode comme indiqué ci-dessous.

C:\PouchDB_Examples >node Synchronising_databases.js

Cela synchronise les deux bases de données remoteDB et localDB et affiche un message sur la console comme indiqué ci-dessous.

Databases synchronized successfully.

Après avoir synchronisé les deux bases de données, visitez le http://127.0.0.1:5984/_utils/index.html et sélectionnez le remote_database. Vous pouvez observer que les documents de la base de données locale (003, 004, 005) ont été copiés dans cette base de données comme indiqué ci-dessous.

De la même manière, si vous récupérez le contenu du local_database stockés dans PouchDB, vous pouvez observer que les documents de la base de données stockée dans CouchDB ont été copiés ici.

[ 
   { 
      id: '001',
      key: '001',
      value: { rev: '1-23cf3767e32a682c247053b16caecedb' },
      doc: { 
         name: 'Geeta',
         age: 25,
         Designation: 'Programmer',
         _id: '001',
         _rev: '1-23cf3767e32a682c247053b16caecedb' 
      } 
   },
   { 
      id: '002',
      key: '002',
      value: { rev: '1-d5bcfafbd4d4fae92fd7fc4fdcaa3a79' },
      doc: { 
         name: 'Zara Ali',
         age: 24,
         Designation: 'Manager',
         _id: '002',
         _rev: '1-d5bcfafbd4d4fae92fd7fc4fdcaa3a79' 
      } 
   },
   { 
      id: '003',
      key: '003',
      value: { rev: '1-bf4619471ac346fdde46cfa8fbf3587f' },
      doc: { 
         name: 'Ram',
         age: 26,
         Designation: 'Programmer',
         _id: '003',
         _rev: '1-bf4619471ac346fdde46cfa8fbf3587f' 
      } 
   },
   { 
      id: '004',
      key: '004',
      value: { rev: '1-29b8f803958c994e3eb37912a45d869c' },
      doc: { 
         name: 'Robert',
         age: 27,
         Designation: 'Programmer',
         _id: '004',
         _rev: '1-29b8f803958c994e3eb37912a45d869c' 
      } 
   },
   { 
      id: '005',
      key: '005',
      value: { rev: '1-0eb89f71998ffa8430a640fdb081abd2' },
      doc: { 
         name: 'Rahim',
         age: 28,
         Designation: 'Programmer',
         _id: '005',
         _rev: '1-0eb89f71998ffa8430a640fdb081abd2' 
      } 
   } 
]

Vous pouvez réécrire le programme ci-dessus en utilisant le sync() méthode fournie par PouchDB au lieu des deux méthodes replicate.to() et replicate.from() comme indiqué ci-dessous.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating local database object
var localDB = new PouchDB('local');

//Creating remote database object
var remoteDB = new PouchDB('http://localhost:5984/remote_database');

//Synchronising Remote and local databases
localDB.sync(remoteDB, function(err, response) {
   if (err) {
      return console.log(err);
   } else {
      console.log(response);
   }
});

Lors de l'exécution du programme ci-dessus, il synchronise les deux bases de données affichant le message suivant.

{ 
   push: { 
      ok: true,
      start_time: Fri Mar 25 2016 15:54:37 GMT+0530 (India Standard Time),
      docs_read: 6,
      docs_written: 6,
      doc_write_failures: 0,
      errors: [],
      last_seq: 10,
      status: 'complete',
      end_time: Fri Mar 25 2016 15:54:37 GMT+0530 (India Standard Time) 
   },
   pull: { 
      ok: true,
      start_time: Fri Mar 25 2016 15:54:37 GMT+0530 (India Standard Time),
      docs_read: 0,
      docs_written: 0,
      doc_write_failures: 0,
      errors: [],
      last_seq: 2,
      status: 'complete',
      end_time: Fri Mar 25 2016 15:54:37 GMT+0530 (India Standard Time) 
   } 
}

Dans ce chapitre, nous discuterons des concepts tels que le compactage et la récupération de données en vrac à partir de PouchDB.

Compactage

Vous pouvez réduire la taille d'une base de données en supprimant les données inutilisées à l'aide de compact()méthode. Vous pouvez compacter une base de données locale ainsi qu'une base de données distante à l'aide de cette méthode.

Voici un exemple illustrant l'utilisation du compact() méthode dans PouchDB.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('sample_database');

db.compact(function (err, result) {
   if (err) {
      return console.log(err);
   } else {
      console.log(result);
   }
});

BulkGet, méthode

Vous pouvez récupérer un ensemble de documents en masse à l'aide du bulkGet()méthode. Pour cette méthode, vous devez passer un ensemble d'identifiants et de _rev.

Voici un exemple illustrant l'utilisation du bulkGet() méthode dans PouchDB.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Preparing documents
//Inserting Document
db.bulkGet({docs: [
   { id: "001", rev: "1-5dc593eda0e215c806677df1d12d5c47"},
   { id: "002", rev: "1-2bfad8a9e66d2679b99c0cab24bd9cc8"},
   { id: "003", rev: "1-7cff4a5da1f97b077a909ff67bd5b047"} ]}, function(err, result) {
   if (err) {
      return console.log(err);
   } else {
      console.log(result);
   }
});