PouchDB - Kurzanleitung

Dieses Kapitel enthält eine kurze Einführung in PouchDB mit seinen Funktionen und seiner Funktionsweise.

Was ist PouchDB?

PouchDB ist eine Open Source in-browser database APIgeschrieben in JavaScript. Es ist nach dem Vorbild von Couch DB & minuss; eine NoSQL-Datenbank. Mit dieser API können wir Anwendungen erstellen, die offline und online funktionieren. Es verwendet intern WebSQL und IndexedDB, um Daten zu speichern.

Wie funktioniert es?

Wenn die Anwendung in PouchDB offline ist, werden die Daten lokal mithilfe von WebSQL und IndexedDB im Browser gespeichert. Wenn die Anwendung wieder online ist, wird sie mit CouchDB und kompatiblen Servern synchronisiert.

Mit PouchDB können Sie nahtlos mit lokalen und entfernten Datenbanken kommunizieren, ohne einen Unterschied zu bemerken.

Funktionen von PouchDB

Im Folgenden sind die Funktionen von PouchDB aufgeführt:

Cross Browser - Die von PouchDB bereitgestellte API funktioniert in jeder Umgebung gleich. Daher können wir eine PouchDB-Anwendung in verschiedenen Browsern ausführen.
Light Weight - PouchDB ist eine sehr leichte API, die auch einfach mit einem Skript-Tag integriert werden kann.
Easy to Learn - Wenn Sie Vorkenntnisse in einer Programmiersprache haben, ist es einfach, PouchDB zu lernen.
Open Source - PouchDB ist eine Open Source-Anwendung und auf GitHub verfügbar.

Vorteile von PouchDB

Im Folgenden sind die Vorteile von PouchDB aufgeführt:

Da sich PouchDB im Browser befindet, müssen keine Abfragen über das Netzwerk ausgeführt werden. Dies führt zu einer schnelleren Ausführung von Abfragen.
Sie können die Daten mit jedem der unterstützten Server synchronisieren und auf diese Weise Apps sowohl online als auch offline ausführen.

Browser, die PouchDB unterstützen

Im Folgenden sind die Browser aufgeführt, die PouchDB unterstützen:

Firefox 29+ (einschließlich Firefox OS und Firefox für Android)
Chrome 30+
Safari 5+
Internet Explorer 10+
Opera 21+
Android 4.0+
iOS 7.1+
Windows Phone 8+

In diesem Kapitel wird erläutert, wie Sie PouchDB herunterladen und auf Ihrem System installieren.

PouchDB installieren

Um mit PouchDB arbeiten zu können, müssen Sie die Datei herunterladen .jsDatei und fügen Sie es in Ihr Skript. Im Folgenden finden Sie die Schritte zum Installieren von PouchDB.

Schritt 1

Besuchen Sie die Homepage der PouchDB-Website, indem Sie auf den folgenden Link klicken:

https://PouchDB.com/

Schritt 2

Klicken Sie oben rechts auf der Webseite auf die Schaltfläche Herunterladen (siehe Abbildung oben). Dies wird heruntergeladenPouchDB-5.3.0.min.js in Ihrem System.

Schritt 3

Kopieren Sie die und fügen Sie sie ein PouchDB-5.3.0.min.js in Ihr Arbeitsverzeichnis und fügen Sie es in Ihr JavaScript ein, wie im folgenden Befehl gezeigt.

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

Pouch mit Node.js installieren

Sie können PouchDB auch als Node.js-Modul installieren. Im Folgenden finden Sie die Schritte zum Installieren von PouchDB mit Node.js.

Schritt 1

Installieren Sie Node.js, indem Sie die Schritte im Abschnitt Installieren von Node.js in unserem Kaffee-Skript- Tutorial ausführen.

Schritt 2

Öffnen Sie die Eingabeaufforderung und führen Sie den folgenden Befehl aus. Dadurch wird das PouchDB-Knotenmodul in Ihrem System installiert.

npm install --save PouchDB

Herunterladen von CouchDB

Im Offline-Modus speichert PouchDB Daten lokal und funktioniert wie eine App. Sie können online darauf zugreifen, indem Sie eine Verbindung mit kompatiblen Servern herstellen. Wie wir wissen, kann PouchDB mit CouchDB verbunden werden. Lassen Sie uns also auch CouchDB installieren. Im Folgenden finden Sie die Schritte zum Installieren von CouchDB.

Schritt 1

Die offizielle Website für CouchDB ist http://couchdb.apache.org. Wenn Sie auf den angegebenen Link klicken, können Sie die Homepage der offiziellen CouchDB-Website aufrufen, wie im folgenden Screenshot gezeigt.

Schritt 2

Wenn Sie auf den Download-Button klicken, wird eine Seite angezeigt, auf der die Download-Links von CouchDB in verschiedenen Formaten bereitgestellt werden. Der folgende Schnappschuss zeigt dasselbe.

Schritt 3

Wählen Sie den Download-Link für Windows-Systeme und einen der bereitgestellten Spiegel, um den Download zu starten.

CouchDB installieren

Eine ausführbare Windows-Datei setup-couchdb-1.6.1_R16B02.exeDie Datei wird auf Ihr System heruntergeladen. Führen Sie die Setup-Datei aus und fahren Sie mit der Installation fort.

Öffnen Sie nach erfolgreicher Installation von CouchDB in Ihrem System den Ordner, in dem CouchDB installiert wurde, wechseln Sie in den Ordner bin und starten Sie den Server, indem Sie eine Skriptdatei mit dem Namen ausführen couchdb.bat.

Öffnen Sie nach der Installation die integrierte Weboberfläche von CouchDB, indem Sie den folgenden Link aufrufen: http://127.0.0.1:5984/. Wenn alles gut geht, erhalten Sie eine Webseite mit der folgenden Ausgabe.

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

Sie können mit der CouchDB-Weboberfläche unter der folgenden URL interagieren:

http://127.0.0.1:5984/_utils/

Dies zeigt Ihnen die Indexseite von Futon, der Weboberfläche von CouchDB.

Sie können eine Datenbank in PouchDB mit dem PouchDB-Konstruktor erstellen.

Syntax

Es folgt die Syntax der Verwendung des PouchDB-Konstruktors. Dazu müssen Sie den Namen der Datenbank als Parameter übergeben.

new PouchDB(Database_name)

Beispiel

So erstellen Sie eine Datenbank in PouchDB mit nodeZunächst müssen Sie das PouchDB-Paket über das require() Methode und dann können Sie eine Datenbank erstellen, wie im folgenden Beispiel gezeigt.

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

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

Speichern Sie den obigen Code in einer Datei mit dem Namen Create_Database.js. Öffnen Sie die Eingabeaufforderung und führen Sie die JavaScript-Datei mit ausnode Wie nachfolgend dargestellt.

C:\PouchDB_Examples>node Create_Database.js

Dadurch wird lokal eine Datenbank erstellt (Sie können den Ordner im aktuellen Verzeichnis sehen), in der die folgende Meldung angezeigt wird.

Database created Successfully.

Sie können die grundlegenden Informationen über die Datenbank mit der genannten Methode abrufen info()

Syntax

Es folgt die Syntax der Verwendung von info()Methode von PouchDB. Diese Methode akzeptiert eine Rückruffunktion.

db.info([callback])

Beispiel

Im Folgenden finden Sie ein Beispiel für das Abrufen von Datenbankinformationen mithilfe von info()Methode. Hier zeigen wir die Informationen der genannten Datenbank anmy_database. Im Fehlerfall wird der Fehler auf der Konsole angezeigt.

//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);
   }
});

Speichern Sie den obigen Code in einer Datei mit dem Namen Database_info.js. Öffnen Sie die Eingabeaufforderung und führen Sie die JavaScript-Datei mit ausnode Wie nachfolgend dargestellt.

C:\PouchDB_Examples>node Database_info.js

Dadurch werden die Informationen der angegebenen Datenbank wie folgt angezeigt.

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

Remote-Datenbankinfo

Auf die gleiche Weise erhalten Sie die Informationen einer Datenbank, die remote auf dem Server (CouchDB) gespeichert ist. Dazu müssen Sie anstelle des Datenbanknamens den Pfad zur erforderlichen Datenbank in CouchDB übergeben.

Beispiel

Im Folgenden finden Sie ein Beispiel für das Abrufen von Informationen einer Datenbank, die auf dem CouchDB-Server gespeichert ist. Dieser Code gibt Ihnen Informationen zu einer Datenbank mit dem Namenmy_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);
   }
});

Speichern Sie den obigen Code in einer Datei mit dem Namen Database_ Remote_info.js. Öffnen Sie die Eingabeaufforderung und führen Sie die JavaScript-Datei mit ausnode Wie nachfolgend dargestellt.

C:\PouchDB_Examples>node Database_Remote_info.js

Dadurch werden die Informationen der angegebenen Datenbank wie folgt angezeigt.

{ 
   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' 
}

Sie können eine Datenbank in PouchDB mit dem löschen db.destroy() Methode.

Syntax

Es folgt die Syntax der Verwendung von db.destroy()Methode. Diese Methode akzeptiert eine Rückruffunktion als Parameter.

db.destroy()

Beispiel

Im Folgenden finden Sie ein Beispiel für das Löschen einer Datenbank in PouchDB mithilfe von destroy()Methode. Hier löschen wir die genannte Datenbankmy_database, erstellt in den vorherigen Kapiteln.

//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”);
   }
});

Speichern Sie den obigen Code in einer Datei mit dem Namen Delete_Database.js. Öffnen Sie die Eingabeaufforderung und führen Sie die JavaScript-Datei mit aus node Wie nachfolgend dargestellt.

C:\PouchDB_Examples >node Delete_Database.js

Dadurch wird die genannte Datenbank gelöscht my_database die lokal gespeichert wird und die folgende Meldung anzeigt.

Database Deleted

Löschen einer entfernten Datenbank

Auf die gleiche Weise können Sie eine Datenbank löschen, die remote auf dem Server (CouchDB) gespeichert ist.

Dazu müssen Sie anstelle eines Datenbanknamens den Pfad an die Datenbank übergeben, die in CouchDB gelöscht werden muss.

Beispiel

Angenommen, es gibt eine Datenbank mit dem Namen my_databaseauf dem CouchDB-Server. Wenn Sie dann die Liste der Datenbanken in CouchDB mithilfe der URL überprüfenhttp://127.0.0.1:5984/_utils/index.html Sie erhalten den folgenden Screenshot.

Im Folgenden finden Sie ein Beispiel für das Löschen einer Datenbank mit dem Namen my_database that is saved in the CouchDB server.

//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");
   }
});

Save the above code in a file with the name Remote_Database_Delete.js. Open the command prompt and execute the JavaScript file using node as shown below.

C:\PouchDB_Examples >Remote_Database_Delete.js

This deletes the specified database from PouchDB displaying the following message.

Database Deleted

Verification

After executing the above program, if you visit the URL again, you will get the following screenshot. Here you can observe only two databases since my_database was deleted.

You can create a document in PouchDB using the db.put() method.

Syntax

Following is the syntax of using the db.put() method of PouchDB. You can store the document that is to be created in PouchDB, in a variable and pass as a parameter to this method. In addition, this method also accepts a callback (optional) function as a parameter.

db.put(document, callback)

Example

Following is an example of creating a document in PouchDB using the put() method. The document we create should be of JSON format, a set of key-value pairs separated by comma (,) and enclosed within curly braces ({}).

//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");
   }
});

Save the above code in a file with name Create_Document.js. Open the command prompt and execute the JavaScript file using node as shown below.

C:\PouchDB_Examples >node Create_Document.js

This creates the given document in PouchDB database named my_database, which is stored locally, displaying the following message.

Document created Successfully

Inserting a Document in a Remote Database

You can also insert a document in the database that is stored remotely on the server (CouchDB).

To do so, instead of database name you need to pass the path to the database where you want to create documents in CouchDB.

Example

Suppose there is a database named my_database in the CouchDB server. Then, if you verify the list of databases in CouchDB using the URL http://127.0.0.1:5984/_utils/index.html you will get the following screenshot.

Now, if you click on the database named my_database, you will find an empty database as shown in the following screenshot.

Following is an example of inserting a document in a database named my_database that is saved in the CouchDB server.

//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");
   }
});

Save the above code in a file with the name Remote_Create_Document.js. Open the command prompt and execute the JavaScript file using node as shown below.

C:\PouchDB_Examples >node Remote_Create_Document.js

This creates the given document in PouchDB database named my_database which is stored in CouchDB, displaying the following message.

Document created Successfully

Verification

After executing the above program, if you visit the my_database again, you can observe the document created as shown in the following screenshot.

You can read/retrieve the contents of a document in PouchDB using the db.get() method.

Syntax

Following is the syntax of using the db.get() method of PouchDB. This method accepts the document id and an optional callback function.

db.get(document, callback)

Example

Following is an example of reading the contents of a document in PouchDB using the get() method.

//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);
   }
});

Save the above code in a file with name Read_Document.js. Open the command prompt and execute the JavaScript file using node as shown below.

C:\PouchDB_Examples >node Read_Document.js

This reads the contents of the given document that exists in the database named my_database which is stored locally. The following message gets displayed on the console.

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

Reading a Document from a Remote Database

You can also read a document from the database that is stored remotely on the server (CouchDB).

To do so, instead of a database name, you need to pass the path to the database in CouchDB, which contains the document that is to be read.

Example

Suppose, there is a database named my_database in the CouchDB server. Then, if you verify the list of databases in CouchDB using the URL http://127.0.0.1:5984/_utils/index.html you will get the following screenshot.

By clicking on the database named my_database you can see the following screenshot. Here, you can observe that this database contains a document with id 001.

Following is an example of reading the contents of the document having id as “001” that exists in a database named my_database, which is stored in the CouchDB server.

//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);
   }
});

Save the above code in a file with the name Remote_Read_Document.js. Open the command prompt and execute the JavaScript file using node as shown below.

C:\PouchDB_Examples >node Remote_Read_Document.js

This reads the contents of the given document that exists in the database named my_database which is stored in CouchDB. The following message is displayed on the console.

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

Whenever, we create a document in PouchDB, a new field _rev is generated, and it is known as revision marker. The _rev‘s value is a unique random number, each time we make changes to the document the value of _rev is changed.

You can update an existing document in PouchDB using the (_rev). To do so, first of all retrieve the _rev value of the document we want to update. Now, place the contents that are to be updated along with the retrieved _rev value in a new document, and finally insert this document in PouchDB using the put() method.

Example

Assume we have a document in PouchDB with id 001 which has details of a person. In order to update this document, we should have its rev number. Therefore, to retrieve the contents of the document the following code is used.

//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);
   }
});

On executing the above code, you will receive the following output.

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

Now, using the _rev you can update the value of the key “age” to 26, as shown in the following code.

//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);
   }
});

Save the above code in a file with the name Update_Document.js. Open the command prompt and execute the JavaScript file using node as shown below.

C:\Pouch_Examples>node Update_Document.js

This updates the contents of the given document that exists in the database named my_database which is stored locally. The following message is displayed on the console.

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

Updating a Document in a Remote Database

You can also update an existing document in a database that is stored remotely on the server (CouchDB).

To do so, instead of a database name you need to pass the path to the database in CouchDB, which contains the document that is to be updated.

Example

By clicking on the database named my_database, you can see the following screenshot. Here, you can observe that this database contains a document with id 001.

Following is an example of updating the age of the document having id as “001” that exists in a database named my_database which is stored in the CouchDB server.

//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);
   }
});

Save the above code in a file with the name Remote_Update_Document.js. Open the command prompt and execute the JavaScript file using node as shown below.

C:\PouchDB_Examples >node Remote_Update_Document.js

This updates the contents of the given document that exists in the database named my_database which is stored in CouchDB. The following message is displayed on the console.

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

You can delete a document from a database that exists in PouchDB using the db.remove() method.

Syntax

Following is the syntax of using the db.remove() method of PouchDB. To this method, we have to pass id and _rev to delete an existing document as shown in the following code. This method accepts an optional callback function. We can also pass the complete document instead of id and _rev.

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

Example

Assume we have a document in PouchDB with id 001 which have the details of a person. In order to delete this document along with its id we should also have its _rev number. Therefore, retrieve the contents of the document as shown in the following code.

//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);
   }
});

Executing the above code gives the following output.

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

Now, using the _rev and id of the document you can delete this by using the remove() method as shown in the following code.

//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");
   }
});

Save the above code in a file with the name Delete_Document.js. Open the command prompt and execute the JavaScript file using node as shown below.

C:\PouchDB_Examples >node Delete_Document.js

This deletes the contents of the given document that exists in the database named my_database which is stored locally. The following message is displayed.

Document deleted successfully

Deleting a Document from a Remote Database

You can also delete an existing document from the database that is stored remotely on the server (CouchDB).

To do so, instead of a database name, you need to pass the path to the database in CouchDB, which contains the document that is to be read.

Example

By clicking on the database named my_database you can see the following screenshot. Here, you can observe that the database contains a document with id 001.

Following is an example of deleting the contents of the document having id “001” that exists in a database named my_database which is stored in the CouchDB server.

//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");
   }
});

Save the above code in a file with name Remote_Delete_Document.js. Open the command prompt and execute the JavaScript file using node as shown below.

C:\PouchDB_Examples >node Remote_Delete_Document.js

This deletes the given document that exists in the database named my_database which is stored in CouchDB. The following message is displayed.

Document deleted successfully

You can create an array (batch) of documents in PouchDB using the db.bulkDocs() method. While creating documents, using this method if we do not provide _id values, on our behalf PouchDB generates unique ids for all the documents in the bulk.

Syntax

Following is the syntax of using the db.bulkDocs() method of PouchDB. You can store all the documents that are to be created in PouchDB in an array and pass it to this method as a parameter. In addition to it, this method also accepts a callback (optional) function as a parameter.

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

Example

Following is an example of creating multiple documents in PouchDB using the db.bulkDocs () method. The documents we create should be of JSON format, a set of key-value pairs separated by comma (,) and enclosed within curly braces ({}).

//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");
   }
});

Save the above code in a file with name Create_Batch.js. Open the command prompt and execute the JavaScript file using node as shown below.

C:\PouchDB_Examples >node Create_Batch.js

This creates the given document in PouchDB database named my_database which is stored locally. The following message gets displayed.

Documents created Successfully

Inserting a Batch in a Remote Database

You can insert an array of documents in the database that is stored remotely on the server (CouchDB).

To do so, instead of a database name you need to pass the path to the database where we want to create documents in CouchDB.

Example

Following is an example of inserting an array of documents in the database named my_database which is saved in the CouchDB server.

//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");
   }
});

Save the above code in a file with the name Remote_Create_Batch.js. Open the command prompt and execute the JavaScript file using node as shown below.

C:\PouchDB_Examples >node Remote_Create_Batch.js

This creates the given documents in PouchDB database named my_database which is stored in CouchDB. The following message is displayed.

Document created Successfully

Verification

After executing the above program if you visit the my_database again, you can observe the documents created as shown in the following screenshot.

You can read/retrieve multiple/bulk documents from a database in PouchDB using the allDocs() method.

Syntax

Following is the syntax of using the db.allDocs() method of PouchDB. This method accepts an optional callback function.

db.allDocs()

Example

Following is an example of retrieving all the documents in a database named my_database that is stored locally, using db.allDocs() method. This method retrieves the array of documents in the form of objects, to get the contents of each document you need to call as docs.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);
   }
});

Save the above code in a file with the name Read_All_Document.js. Open the command prompt and execute the JavaScript file using node as shown below.

C:\PouchDB_Examples >node Read_All_Document.js

This reads all the documents that exists in the database named my_database which is stored locally. The following message is displayed on the 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' } 
   }
]

In general, as shown in the above result, using allDocs() method you can see only the _id, key and _rev fields of each document. However, to include the whole document in the result, you have to make the optional parameter include_docs true as shown below.

//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);
   }
});

Executing the above code gives you a list of complete documents in the specified documents as shown in the following code.

[ 
   { 
      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' 
      } 
   }
]

Reading a Batch from a Remote Database

You can also fetch all the documents from the database that is stored remotely on the server (CouchDB).

To do so instead of a database name, you need to pass the path to the database in CouchDB, which contains the document that is to be read.

Example

Following is an example of reading all the documents that exist in a database named my_database which is stored in the CouchDB server.

//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);
   }
});

Save the above code in a file with the name Remote_Read_AllDocument.js. Open the command prompt and execute the JavaScript file using node as shown below.

C:\PouchDB_Examples >node Remote_Read_AllDocument.js

This reads the contents of the given document that exists in the database named my_database which is stored in CouchDB, and displays on the console as shown below.

[ 
   { 
      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' 
      } 
   } 
]

You can update an array of documents in PouchDB at once using the bulkDocs() method. To do so you need to create an array of documents where, each document contains _id, _rev and the values that are to be updated.

Suppose the database named my_database that is stored locally in PouchDB contains 3 documents namely doc1, doc2, doc3 with the following contents.

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'}

Suppose we have to increase the age values in all the 3 documents by 2 years. For this to happen, first you need to get the _rev values. Therefore, fetch the contents of these documents using the following code.

//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);
   }
});

Save the above code as bulk_fetch.js. On executing, the above program gives you the _id and _rev values of the documents in the database as shown below.

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

Now, you can update the documents using their respective _id and _rev values as shown below.

//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");
   }
});

Save the above code in a file with the name Update_All_Document.js. Open the command prompt and execute the JavaScript file using node as shown below.

C:\PouchDB_Examples >node Update_All_Document.js

This updates all the documents that exists in the database named my_database which is stored locally, displaying the following message.

Documents Updated Successfully

Now, if you execute the bulk_fetch.js program by adding {include_docs: true} as a parameter to allDocs() function, before the callback, then, you will can see the values of the documents updated, as shown below.

[ 
   { 
      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' 
      } 
   } 
]

Updating Batch from a Remote Database

You can update all the documents from the database that is stored remotely on the server (CouchDB).

To do so, instead of a database name, you need to pass the path to the database in CouchDB, which contains the document that is to be read.

Example

And assume if we select the database named my_database, you can observe that it contains 3 documents as shown in the following screenshot.

Now, fetch the contents of these documents using the following code.

//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);
   }
});

Save the above code as remote_bulk_fetch.js. On executing, the above program gives you the contents of all the documents in the database as shown below.

[ 
   { 
      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' 
      } 
   } 
]

Following is an example of updating all the documents that exists in a database named my_database which is stored in the CouchDB server.

//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"); 
   } 
});

Save the above code in a file with the name Remote_Update_Document.js. Open the command prompt and execute the JavaScript file using node as shown below.

C:\PouchDB_Examples >node Remote_Update_Document.js

This updates the contents of all given document that exists in the database named my_database which is stored in CouchDB, and displays the following message.

Documents Updated Successfully

Now, if you execute the remote_bulk_fetch.js program you will can see the values of the documents updated, as shown below.

[ 
   { 
      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 
      } 
   } 
]

Sie können eine Reihe von Dokumenten in PouchDB gleichzeitig mit dem löschen bulkDocs()Methode. Dazu müssen Sie ein Array von Dokumenten erstellen, die dort gelöscht werden sollen, wo jedes Dokument enthalten sein soll_id und _rev. Zusätzlich müssen Sie ein weiteres Schlüssel-Wert-Paar hinzufügen_deleted: true.

Angenommen, die Datenbank heißt my_database Das lokal in PouchDB gespeicherte Dokument enthält 3 Dokumente, nämlich doc1, doc2, doc3 mit den folgenden Inhalten.

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'}

Und sagen wir, wir müssen alle drei Dokumente löschen. Dann müssen Sie zuerst ihre bekommen_revWerte. Rufen Sie daher den Inhalt dieser Dokumente mit dem folgenden Code ab.

//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);
   }
});

Speichern Sie den obigen Code als bulk_fetch.js. Wenn Sie das obige Programm ausführen, erhalten Sie die _id- und _rev-Werte der Dokumente in der Datenbank, wie unten gezeigt.

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

Jetzt können Sie die Dokumente mit ihren jeweiligen löschen _id und _rev Werte wie unten gezeigt.

//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");
   }
});

Speichern Sie den obigen Code in einer Datei mit dem Namen Delete_All_Document.js. Öffnen Sie die Eingabeaufforderung und führen Sie die JavaScript-Datei mit dem unten gezeigten Knoten aus.

C:\PouchDB_Examples >node Delete_All_Document.js

Dadurch werden alle Dokumente gelöscht, die in der genannten Datenbank vorhanden sind my_database die lokal gespeichert wird und die folgende Meldung anzeigt.

Documents Deleted Successfully

Nun, wenn Sie die ausführen bulk_fetch.js Programm können Sie eine leere Klammer auf der Konsole beobachten, die anzeigt, dass die Datenbank leer ist, wie unten gezeigt.

[]

Löschen eines Stapels aus einer entfernten Datenbank

Sie können alle Dokumente aus der Datenbank aktualisieren, die remote auf dem Server (CouchDB) gespeichert ist.

Dazu müssen Sie anstelle eines Datenbanknamens den Pfad zur Datenbank in CouchDB übergeben, die das zu lesende Dokument enthält.

Beispiel

Wenn wir die genannte Datenbank auswählen my_databasekönnen Sie beobachten, dass es 3 Dokumente enthält, wie im folgenden Screenshot gezeigt.

Im Folgenden finden Sie ein Beispiel für das Löschen aller Dokumente, die in einer Datenbank mit dem Namen vorhanden sind my_database welches auf dem CouchDB-Server gespeichert ist.

//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");
   }
});

Speichern Sie den obigen Code in einer Datei mit Namen Remote_delete_AllDocuments.js. Öffnen Sie die Eingabeaufforderung und führen Sie die JavaScript-Datei mit dem unten gezeigten Knoten aus.

C:\PouchDB_Examples >node Remote_Delete_AllDocuments.js

Dadurch wird der Inhalt aller angegebenen Dokumente gelöscht, die in der genannten Datenbank vorhanden sind my_database Dies wird in CouchDB gespeichert und zeigt die folgende Meldung an.

Documents Deleted Successfully

Sie können ein Binärobjekt mit dem Befehl an ein Dokument anhängen putAttachment() Methode in PouchDB.

Syntax

Es folgt die Syntax von putAttachment(). An diese Methode müssen wir die Dokument-ID, die Anhangs-ID und den MIME-Typ zusammen mit dem Anhang übergeben. Diese Methode akzeptiert auch eine optionale Rückruffunktion.

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

Wir können den Anhang mithilfe von Blob- oder Pufferobjekten vorbereiten, wobei blob wird während der Arbeit mit dem Browser und verwendet buffer wird beim Arbeiten mit verwendet Node.jsDa wir unsere Programme in Node.js demonstrieren, verwenden wir Pufferobjekte, um Dokumente vorzubereiten.

Beispiel

Im Folgenden finden Sie ein Beispiel für das Erstellen eines Dokuments mit einem Anhang in einer Datenbank mit dem Namen my_database in PouchDB mit putAttachment() Methode.

//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") 
   } 
});

Speichern Sie den obigen Code in einer Datei mit Namen Add_Attachment.js. Öffnen Sie die Eingabeaufforderung und führen Sie die JavaScript-Datei mit ausnode Wie nachfolgend dargestellt.

C:\PouchDB_Examples >node Add_Attachment.js

Dadurch wird ein leeres Dokument in der genannten Datenbank erstellt, dem ein Anhang hinzugefügt wird my_database Dies wird in PouchDB gespeichert und zeigt die folgende Meldung an.

Attachment added successfully

Sie können überprüfen, ob der Anhang hinzugefügt wurde, indem Sie das Dokument mit dem folgenden Code lesen.

//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); 
   } 
});

Speichern Sie den obigen Code als read_doc.jsund ausführen. Wenn Sie dieses Programm ausführen, sehen Sie den folgenden Inhalt des Dokuments.

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

Hinzufügen eines Anhangs zu einem vorhandenen Dokument

Angenommen, in einer Datenbank befindet sich ein Dokument mit dem Namen my_database PouchDB mit ID '002'. Sie können den Inhalt abrufen, indem Sie das ausführenread_doc.js durch Ändern des ID-Werts in 002, Wie nachfolgend dargestellt.

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

Jetzt können Sie diesem Dokument einen Anhang hinzufügen _rev Wert.

//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") 
   } 
});

Speichern Sie den obigen Code in einer Datei mit dem Namen Add_Attachment_to_doc.js. Öffnen Sie die Eingabeaufforderung und führen Sie die JavaScript-Datei mit ausnode Wie nachfolgend dargestellt.

C:\PouchDB_Examples >node Add_Attachment_to_doc.js

Dadurch wird dem angegebenen Dokument ein Anhang hinzugefügt, in dem die folgende Meldung angezeigt wird.

Attachment added successfully

Wenn Sie den ID-Wert in ändern read_doc.js zu 002 Wenn Sie es ausführen, erhalten Sie die folgende Ausgabe.

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

Hinzufügen eines Anhangs zu einem Remote-Dokument

Sie können dem Dokument, das in einer Datenbank vorhanden ist, die remote auf dem Server (CouchDB) gespeichert ist, sogar einen Anhang hinzufügen.

Dazu müssen Sie anstelle eines Datenbanknamens den Pfad zur Datenbank in CouchDB übergeben, die das zu lesende Dokument enthält.

Beispiel

Und wenn Sie die genannte Datenbank auswählen my_databasekönnen Sie den Inhalt wie unten gezeigt anzeigen.

Im Folgenden finden Sie ein Beispiel für das Hinzufügen eines Anhangs zum Dokument 001 in einer Datenbank mit dem Namen gespeichert my_database welches auf dem CouchDB-Server gespeichert ist.

//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")
   }
});

Speichern Sie den obigen Code in einer Datei mit dem Namen Remote_Add_Attachment.js. Öffnen Sie die Eingabeaufforderung und führen Sie die JavaScript-Datei mit ausnode Wie nachfolgend dargestellt.

C:\PouchDB_Examples >node Remote_Add_Attachment.js

Dadurch wird dem angegebenen Dokument ein Anhang hinzugefügt, in dem die folgende Meldung angezeigt wird.

Attachment added successfully

Wenn Sie nun das Dokument überprüfen, können Sie den hinzugefügten Anhang beobachten, wie im folgenden Screenshot gezeigt.

Sie können einen Anhang aus PouchDB mit dem abrufen getAttachment()Methode. Diese Methode gibt immer Blob- oder Pufferobjekte zurück.

Syntax

Es folgt die Syntax von getAttachment(). An diese Methode müssen wir die Dokument-ID und die Anhang-ID übergeben. Diese Methode akzeptiert auch eine optionale Rückruffunktion.

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

Beispiel

Im Folgenden finden Sie ein Beispiel für das Abrufen eines Anhangs eines in PouchDB gespeicherten Dokuments mithilfe von getAttachment()Methode. Mit diesem Code versuchen wir, einen Anhang abzurufenatt_1.txt aus dem Dokument 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);
   }
});

Speichern Sie den obigen Code in einer Datei mit dem Namen Retrieve_Attachment.js. Öffnen Sie die Eingabeaufforderung und führen Sie die JavaScript-Datei mit ausnode Wie nachfolgend dargestellt.

C:\PouchDB_Examples >node Retrieve_Attachment.js

Dadurch wird der Anhang des Dokuments abgerufen und wie unten gezeigt auf der Konsole angezeigt.

<Buffer 00>

Anhang aus einem Remote-Dokument abrufen

Sie können auch einen Anhang eines in der Datenbank vorhandenen Dokuments abrufen, das remote auf dem Server (CouchDB) gespeichert ist.

Dazu müssen Sie anstelle eines Datenbanknamens den Pfad zur Datenbank in CouchDB übergeben, die das zu lesende Dokument enthält.

Beispiel

Wenn Sie die genannte Datenbank auswählen my_databasekönnen Sie den Inhalt wie unten gezeigt anzeigen.

Angenommen, dieses Dokument enthält einen Anhang (siehe unten).

Im Folgenden finden Sie ein Beispiel für das Abrufen eines Anhangs des Dokuments 001 das existiert in einer Datenbank mit dem Namen my_database, der auf dem CouchDB-Server gespeichert ist.

//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); 
   } 
});

Speichern Sie den obigen Code in einer Datei mit dem Namen Remote_Retrieve_Attachment.js. Öffnen Sie die Eingabeaufforderung und führen Sie die JavaScript-Datei mit ausnode Wie nachfolgend dargestellt.

C:\PouchDB_Examples >node Remote_Retrieve_Attachment.js

Dadurch wird der Dokumentanhang abgerufen und wie unten gezeigt auf der Konsole angezeigt.

<Buffer 00>

Sie können einen Anhang aus PouchDB mit dem löschen removeAttachment() Methode.

Syntax

Es folgt die Syntax von removeAttachment()Methode. An diese Methode müssen wir die Dokument-ID, die Anhang-ID und den Wert _rev übergeben. Diese Methode akzeptiert auch eine optionale Rückruffunktion.

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

Beispiel

Angenommen, in PouchDB befindet sich ein Dokument mit der ID 001, die ID, Name, Alter, Bezeichnung eines Mitarbeiters sowie einen Anhang wie unten gezeigt enthält.

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

Im Folgenden finden Sie ein Beispiel für das Löschen des Anhangs dieses Dokuments 001 in PouchDB gespeichert, mit removeAttachment() Methode.

//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")
   }
});

Speichern Sie den obigen Code in einer Datei mit dem Namen Remove_Attachment.js. Öffnen Sie die Eingabeaufforderung und führen Sie die JavaScript-Datei mit ausnode Wie nachfolgend dargestellt.

C:\PouchDB_Examples >node Remove_Attachment.js

Dadurch wird der Anhang des Dokuments entfernt und eine Meldung auf der Konsole angezeigt (siehe unten).

Attachment deleted successfully

Nach dem Löschen können Sie den Inhalt des Dokuments überprüfen, indem Sie den folgenden Code ausführen.

//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);
   }
});

Speichern Sie diesen Code als read.jsund ausführen. Bei der Ausführung erhalten Sie den Inhalt des Dokuments nach dem Löschen des Anhangs, wie unten gezeigt.

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

Entfernen des Anhangs aus einem Remote-Dokument

Sie können einen Anhang eines vorhandenen Dokuments in der Datenbank löschen, das remote auf dem Server (CouchDB) gespeichert ist.

Dazu müssen Sie anstelle eines Datenbanknamens den Pfad zur Datenbank in CouchDB übergeben, die das zu lesende Dokument enthält.

Beispiel

Und wenn Sie die genannte Datenbank auswählen my_databasekönnen Sie den Inhalt wie unten gezeigt anzeigen.

Angenommen, dieses Dokument enthält einen Anhang (siehe unten).

Im Folgenden finden Sie ein Beispiel für das Löschen des oben genannten Anhangs des Dokuments 001 das existiert in einer Datenbank mit dem Namen my_database welches auf dem CouchDB-Server gespeichert ist.

//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") 
   } 
});

Speichern Sie den obigen Code in einer Datei mit dem Namen Remote_Delete_Attachment.js. Öffnen Sie die Eingabeaufforderung und führen Sie die JavaScript-Datei mit ausnode Wie nachfolgend dargestellt.

C:\PouchDB_Examples >node Remote_Delete_Attachment.js

Dadurch wird der vorhandene Anhang entfernt und die folgende Meldung angezeigt.

Attachment Deleted successfully

Wenn Sie das Dokument erneut besuchen, können Sie feststellen, dass der Anhang wie im folgenden Screenshot gezeigt gelöscht wurde.

Eine der wichtigsten Funktionen von PouchDB ist die Replikation, dh Sie können eine Kopie einer Datenbank erstellen. Sie können entweder eine lokal gespeicherte PouchDB-Instanz oder eine remote gespeicherte CouchDB-Instanz replizieren.

Syntax

Im Folgenden finden Sie die Syntax zum Replizieren einer Datenbank in PouchDB. Hier eine Kopie dersource databaseist das Ziel. An diese Methode können Sie den Speicherort von Quell- und Zieldatenbanken direkt im String-Format übergeben oder Objekte übergeben, die diese darstellen.

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

Sowohl die Quelle als auch die Ziele können entweder PouchDB-Instanzen oder CouchDB-Instanzen sein.

Replizieren von LocalDB in CouchDB

Angenommen, es gibt eine Datenbank mit dem Namen sample_database in PouchDB und enthält 3 Dokumente doc1, doc2 und doc3 mit den folgenden Inhalten.

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'}

Es folgt ein Beispiel, das eine Kopie der genannten Datenbank erstellt sample_database das ist lokal in CouchDB gespeichert.

//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");

Speichern Sie den obigen Code in einer Datei mit Namen Replication_example.js. Öffnen Sie die Eingabeaufforderung und führen Sie die JavaScript-Datei mit ausnode Wie nachfolgend dargestellt.

C:\PouchDB_Examples >node Replication_example.js

Dadurch wird eine Kopie der Datenbank mit dem Namen sample_database in der CouchDB-Instanz erstellt und eine Meldung auf der Konsole angezeigt, wie unten gezeigt.

Database replicated successfully

Sie können überprüfen, ob die Datenbank in Ihrer CouchDB-Instanz repliziert wurde, indem Sie auf den folgenden Link klicken http://127.0.0.1:5984/_utils/index.html.

Beim Klicken sehen Sie die Liste der Datenbanken in Ihrer CouchDB. Sie können auch beobachten, dass eine Kopie der Datenbanksample_database wird hier erstellt.

Wenn Sie die replizierte Datenbank auswählen, können Sie deren Inhalt wie unten gezeigt anzeigen.

CouchDB auf PouchDB replizieren

Angenommen, es gibt eine Datenbank mit dem Namen Remote_Database in CouchDB und es enthält 3 Dokumente, doc1, doc2 und doc3, mit Inhalten wie unten gezeigt.

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'}

Es folgt ein Beispiel, das eine Kopie der genannten Datenbank erstellt Remote_Database das ist in CouchDB im lokalen Speicher gespeichert.

//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");

Speichern Sie den obigen Code in einer Datei mit dem Namen Replication_example2.js. Öffnen Sie die Eingabeaufforderung und führen Sie die JavaScript-Datei mit ausnode Wie nachfolgend dargestellt.

C:\PouchDB_Examples >node Replication_example2.js

Dadurch wird eine Kopie der Datenbank mit dem Namen erstellt remote_database in der PouchDB-Instanz und zeigt eine Meldung auf der Konsole an, wie unten gezeigt.

Database replicated successfully

Sie können überprüfen, ob die Datenbank in Ihrer Pouch-Instanz repliziert wurde, indem Sie den folgenden Code ausführen.

//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);
   }
});

Wenn die Datenbank beim Ausführen des obigen Codes repliziert wird, erhalten Sie den Inhalt der replizierten Datenbank wie unten gezeigt.

[ 
   { 
      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' 
      } 
   } 
]

Sie können die in PouchDB lokal gespeicherten Datenbanken mit den in CouchDB gespeicherten Datenbanken synchronisieren. Im vorherigen Kapitel haben wir gesehen, wie Datenbanken mit PouchDB repliziert werden. Dort haben wir die Methode angewendetPouchDB.replicate(source, destination).

Darüber hinaus können wir die Daten mithilfe von von der lokalen Datenbank in die entfernte Datenbank und von der entfernten Datenbank in die lokale Datenbank replizieren replicate.to() und replicate.from() Methoden wie unten gezeigt.

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

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

Wo, localDB ist ein Objekt der Datenbank, das lokal in PouchDB und gespeichert ist remoteDB ist ein Objekt einer Datenbank, die in CouchDB gespeichert ist.

Beispiel

Angenommen, es gibt eine Datenbank mit dem Namen local_database in PouchDB und enthält 3 Dokumente, doc1, doc2 und doc3, deren Inhalt wie unten gezeigt ist.

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'}

Und es gibt eine Datenbank mit dem Namen Remote_Database in CouchDB und es enthält 2 Dokumente doc1, doc2 mit Inhalten wie unten gezeigt.

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

Im Folgenden finden Sie ein Beispiel für die Synchronisierung dieser beiden Datenbanken, wobei eine in PouchDB und die andere in CouchDB gespeichert ist replicate.to() und replicate.from() Methoden.

//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");

Speichern Sie den obigen Code in einer Datei mit dem Namen Synchronising_databases.js. Öffnen Sie die Eingabeaufforderung und führen Sie die JavaScript-Datei mit ausnode Wie nachfolgend dargestellt.

C:\PouchDB_Examples >node Synchronising_databases.js

Dadurch werden die beiden Datenbanken remoteDB und localDB synchronisiert und eine Meldung auf der Konsole angezeigt (siehe unten).

Databases synchronized successfully.

Nach dem Synchronisieren der beiden Datenbanken besuchen Sie die http://127.0.0.1:5984/_utils/index.html und wählen Sie die remote_database. Sie können beobachten, dass die Dokumente der lokalen Datenbank (003, 004, 005) wie unten gezeigt in diese Datenbank kopiert wurden.

Auf die gleiche Weise, wenn Sie den Inhalt der abrufen local_database In PouchDB gespeichert können Sie beobachten, dass Dokumente der in CouchDB gespeicherten Datenbank hier kopiert wurden.

[ 
   { 
      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' 
      } 
   } 
]

Sie können das obige Programm mit dem umschreiben sync() Methode von PouchDB anstelle der beiden Methoden replicate.to() und replicate.from() Wie nachfolgend dargestellt.

//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);
   }
});

Beim Ausführen des obigen Programms werden die beiden Datenbanken synchronisiert, wobei die folgende Meldung angezeigt wird.

{ 
   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) 
   } 
}

In diesem Kapitel werden die Konzepte wie Komprimieren und Abrufen von Massendaten aus PouchDB erläutert.

Verdichtung

Sie können die Größe einer Datenbank reduzieren, indem Sie die nicht verwendeten Daten mit entfernen compact()Methode. Mit dieser Methode können Sie sowohl eine lokale Datenbank als auch eine entfernte Datenbank komprimieren.

Das folgende Beispiel zeigt die Verwendung von compact() Methode in 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-Methode

Sie können eine Reihe von Dokumenten in großen Mengen mit dem abrufen bulkGet()Methode. Für diese Methode müssen Sie eine Reihe von IDs und _revs übergeben.

Das folgende Beispiel zeigt die Verwendung von bulkGet() Methode in 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);
   }
});