Discuss PouchDB ”; Previous Next PouchDB is an open source in-browser database API written in JavaScript. It is modelled after CouchDB – a NoSQL database that powers npm. Using this API, we can build applications that work offline and online. PouchDB uses WebSQL and IndexedDB internally to store the data. This tutorial discusses the basics of PouchDB along with relevant examples for easy understanding. Print Page Previous Next Advertisements ”;
PouchDB – Adding Attachment ”; Previous Next You can attach a binary object to a document using the putAttachment() method in PouchDB. Syntax Following is the syntax of the putAttachment(). To this method, we have to pass the document id, attachment id, MIME type along with the attachment. This method also accepts an optional callback function. db.putAttachment( docId, attachmentId, attachment, type, [callback] ); We can prepare attachment using blob or buffer objects, where blob is used while working with the browser and buffer is used while working with Node.js, since we are demonstrating our programs in Node.js, we use buffer objects to prepare documents. Example Following is an example of creating a document with an attachment, within a database named my_database in PouchDB using putAttachment() method. //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”) } }); Save the above code in a file with name Add_Attachment.js. Open the command prompt and execute the JavaScript file using node as shown below. C:PouchDB_Examples >node Add_Attachment.js This creates an empty document adding an attachment to it, in the database named my_database which is stored in PouchDB, and displays the following message. Attachment added successfully You can verify whether the attachment is added by reading the document using the following code. //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); } }); Save the above code as read_doc.js and execute it. Executing this program, you can see the following contents of the document. { _attachments: { att_1.txt: { content_type: ”text/plain”, digest: ”md5-k7iFrf4NoInN9jSQT9WfcQ==”, data: ”AA==” } }, _id: ”001”, _rev: ”1-620fd5f41d3328fcbf9ce7504338a51d” } Adding Attachment to an Existing Document Suppose, there is a document in a database by the name my_database PouchDB with id ‘002’. You can get the contents of it by executing the read_doc.js by changing the id value to 002, as shown below. { name: ”Raju”, age: 23, designation: ”Designer”, _id: ”002”, _rev: ”1-05ca7b5f3f4762a9fb2d119cd34c8d40” } Now, you can add an attachment to this document using its _rev value. //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”) } }); Save the above code in a file with the name Add_Attachment_to_doc.js. Open the command prompt and execute the JavaScript file using node as shown below. C:PouchDB_Examples >node Add_Attachment_to_doc.js This adds an attachment to the specified document displaying the following message. Attachment added successfully If you change the id value in read_doc.js to 002 and execute it, you will get the following output. { name: ”Raju”, age: 23, designation: ”Designer”, _attachments: { att_1: { content_type: ”text/plain”, digest: ”md5-k7iFrf4NoInN9jSQT9WfcQ==”, data: ”AA==” } }, _id: ”002”, _rev: ”2-3bb4891b954699bce28346723cc7a709” } Adding Attachment to a Remote Document You can even add an attachment to the document existing 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 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. And if you select the database named my_database, you can view its contents as shown below. Following is an example of adding an attachment to the document 001 stored 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”); //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”) } }); Save the above code in a file with the name Remote_Add_Attachment.js. Open the command prompt and execute the JavaScript file using node as shown below. C:PouchDB_Examples >node Remote_Add_Attachment.js This adds an attachment to the specified document displaying the following message. Attachment added successfully Now, if you verify the document, you can observe the attachment added to it as shown in the following screenshot. Print Page Previous Next Advertisements ”;
PouchDB – Delete Document ”; Previous Next 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 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 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 Print Page Previous Next Advertisements ”;
PouchDB – Synchronization ”; Previous Next You can synchronize the databases stored locally in PouchDB with those that are stored in CouchDB. In the previous chapter, we have seen how to replicate databases using PouchDB. There we have used the method PouchDB.replicate(source, destination). In addition to this, we can also replicate the data, from the local database to the remote database, and from the remote database to the local database using replicate.to() and replicate.from() methods as shown below. //Replicating data from local database to remote database localDB.replicate.to(remoteDB); //Replicating data from remote database to local database localDB.replicate.from(remoteDB); Where, localDB is an object of database stored locally in PouchDB and remoteDB is an object of a database that is stored in CouchDB. Example Suppose there is a database with the name local_database in PouchDB, and it contains 3 documents, doc1, doc2, and doc3, having contents as shown below. 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”} And there is a database with the name Remote_Database in CouchDB and it contains 2 documents doc1, doc2, having contents as shown below. doc1 = {_id: ”001”, name: ”Geeta”, age: 25, Designation: ”Programmer”} doc2 = {_id: ”002”, name: ”Zara Ali”, age: 24, Designation: ”Manager”} Following is an example of synchronizing these two databases, where one is stored in PouchDB and other is stored in CouchDB, using the replicate.to() and replicate.from() methods. //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”); Save the above code in a file with the name Synchronising_databases.js. Open the command prompt and execute the JavaScript file using node as shown below. C:PouchDB_Examples >node Synchronising_databases.js This synchronizes the two databases remoteDB and localDB, and displays a message on the console as shown below. Databases synchronized successfully. After synchronizing the two databases visit the http://127.0.0.1:5984/_utils/index.html and select the remote_database. You can observe that the documents of local database (003, 004, 005) were copied in this database as shown below. In the same way, if you fetch the contents of the local_database stored in PouchDB you can get to observe that documents of the database that is stored in CouchDB were copied here. [ { 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” } } ] You can rewrite the above program using the sync() method provided by PouchDB instead of the two methods replicate.to() and replicate.from() as shown below. //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); } }); On executing the above program, it synchronizes the two databases displaying the following message. { 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) } } Print Page Previous Next Advertisements ”;
PouchDB – Fetch Batch ”; Previous Next 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 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. 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” } } ] Print Page Previous Next Advertisements ”;
PouchDB – Retrieving Attachment ”; Previous Next You can retrieve an attachment from PouchDB using the getAttachment() method. This method always returns blob or buffer objects. Syntax Following is the syntax of the getAttachment(). To this method, we have to pass the document id and attachment id. This method also accepts an optional callback function. db.getAttachment( docId, attachmentId, [callback] ); Example Following is an example of retrieving an attachment of a document stored in PouchDB, using getAttachment() method. Using this code, we are trying to retrieve an attachment att_1.txt from the 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); } }); Save the above code in a file with the name Retrieve_Attachment.js. Open the command prompt and execute the JavaScript file using node as shown below. C:PouchDB_Examples >node Retrieve_Attachment.js This retrieves the attachment of the document and displays on the console as shown below. <Buffer 00> Retrieving Attachment from a Remote Document You can also retrieve an attachment of a document existing 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 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. If you select the database named my_database, you can view its contents as shown below. Suppose, there is an attachment in this document as shown below. Following is an example of retrieving an attachment of the document 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”); //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); } }); Save the above code in a file with the name Remote_Retrieve_Attachment.js. Open the command prompt and execute the JavaScript file using node as shown below. C:PouchDB_Examples >node Remote_Retrieve_Attachment.js This retrieves the document attachment and displays it on the console as shown below. <Buffer 00> Print Page Previous Next Advertisements ”;
PouchDB – Create Database ”; Previous Next You can create a database in PouchDB using the PouchDB constructor. Syntax Following is the syntax of using the PouchDB constructor. To this, you need to pass the name of the database as a parameter. new PouchDB(Database_name) Example To create a database in PouchDB using node, first of all, you need to require the PouchDB package using the require() method and then you can create a database as shown in the following example. //Requiring the package var PouchDB = require(”PouchDB”); //Creating the database object var db = new PouchDB(”my_database”); console.log (“Database created Successfully.”); Save the above code in a file with the name Create_Database.js. Open the command prompt and execute the JavaScript file using node as shown below. C:PouchDB_Examples>node Create_Database.js This will create a database locally (you can see the folder in the current directory) displaying the following message. Database created Successfully. Print Page Previous Next Advertisements ”;
PouchDB – Read Document ”; Previous Next 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” } Print Page Previous Next Advertisements ”;
PouchDB – Update Document ”; Previous Next 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 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 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” } Print Page Previous Next Advertisements ”;
PouchDB – Overview ”; Previous Next This chapter provides a brief introduction to PouchDB along with its features and how it works. What is PouchDB? PouchDB is an open source in-browser database API written in JavaScript. It is modelled after Couch DB &minuss; a NoSQL database. Using this API, we can build applications that work offline and online. It internally uses WebSQL and IndexedDB to store data. How Does it Work? In PouchDB, when the application is offline, the data is stored locally using WebSQL and IndexedDB in the browser. When the application is back online, it is synchronized with CouchDB and compatible servers. Using PouchDB, you can communicate with both local and remote databases seamlessly without noticing any difference. Features of PouchDB Following are the features of PouchDB − Cross Browser − The API provided by PouchDB works the same in every environment, therefore, we can run a PouchDB application in various browsers. Light Weight − PouchDB is a very light-weight API, it is also included easily just using a script tag. Easy to Learn − If you have a prior knowledge of any programming language, it is easy to learn PouchDB. Open Source − PouchDB is an Open Source Application and is available on GitHub. Advantages of PouchDB Following are the advantages of PouchDB − Since PouchDB resides inside the browser, there is no need to perform queries over the network, this results in faster execution of queries. You can synchronize the data with any of the supported server and by doing so you can run apps both online and offline. Browsers that Support PouchDB Following are the browsers that support PouchDB − Firefox 29+ (Including Firefox OS and Firefox for Android) Chrome 30+ Safari 5+ Internet Explorer 10+ Opera 21+ Android 4.0+ iOS 7.1+ Windows Phone 8+ Print Page Previous Next Advertisements ”;