Category: pouchdb

  • Khóa học miễn phí PouchDB – Useful Resources nhận dự án làm có lương

    PouchDB – Useful Resources



    The following resources contain additional information on PouchDB. Please use them to get more in-depth knowledge on this.

    Useful Video Courses

    42 Lectures 8.5 hours

    34 Lectures 7 hours

    Most Popular

    73 Lectures 7.5 hours

    31 Lectures 1 hours

    Best Seller

    71 Lectures 2.5 hours

    Most Popular

    20 Lectures 49 mins


    Khóa học lập trình tại Toidayhoc vừa học vừa làm dự án vừa nhận lương: Khóa học lập trình nhận lương tại trung tâm Toidayhoc

  • Khóa học miễn phí PouchDB – Discussion nhận dự án làm có lương

    Discuss PouchDB



    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.


    Khóa học lập trình tại Toidayhoc vừa học vừa làm dự án vừa nhận lương: Khóa học lập trình nhận lương tại trung tâm Toidayhoc

  • Khóa học miễn phí PouchDB – Create Batch nhận dự án làm có lương

    PouchDB – Create Batch



    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

    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.

    Inserting a Batch in a Remote Database

    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.

    Inserting Batch Verification

    Khóa học lập trình tại Toidayhoc vừa học vừa làm dự án vừa nhận lương: Khóa học lập trình nhận lương tại trung tâm Toidayhoc

  • Khóa học miễn phí PouchDB – Fetch Batch nhận dự án làm có lương

    PouchDB – Fetch Batch



    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.

    Reading a Batch from a Remote Database

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

    Khóa học lập trình tại Toidayhoc vừa học vừa làm dự án vừa nhận lương: Khóa học lập trình nhận lương tại trung tâm Toidayhoc

  • Khóa học miễn phí PouchDB – Update Batch nhận dự án làm có lương

    PouchDB – Update Batch



    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

    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.

    Updating Batch from a Remote Database

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

    Updating Batch

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

    Khóa học lập trình tại Toidayhoc vừa học vừa làm dự án vừa nhận lương: Khóa học lập trình nhận lương tại trung tâm Toidayhoc

  • Khóa học miễn phí PouchDB – Delete Batch nhận dự án làm có lương

    PouchDB – Delete Batch



    You can delete an array of documents in PouchDB at once using the bulkDocs() method. To do so you need to create an array of documents that are to be deleted where, each document should contain _id and _rev. In addition to these you have to add another key-value pair _deleted: true.

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

    And say, we have to delete all the three documents. Then, first of all you need to get their _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. 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 delete 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_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");
       }
    });
    

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

    C:PouchDB_Examples >node Delete_All_Document.js
    

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

    Documents Deleted Successfully
    

    Now, if you execute the bulk_fetch.js program, you can observe an empty brace on the console indicating that the database is empty, as shown below.

    []
    

    Deleting 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

    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.

    Deleting Batch from a Remote Database

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

    Deleting Batch

    Following is an example of deleting 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'');
    
    //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");
       }
    });
    

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

    C:PouchDB_Examples >node Remote_Delete_AllDocuments.js
    

    This deletes 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 Deleted Successfully
    

    Khóa học lập trình tại Toidayhoc vừa học vừa làm dự án vừa nhận lương: Khóa học lập trình nhận lương tại trung tâm Toidayhoc

  • Khóa học miễn phí PouchDB – Replication nhận dự án làm có lương

    PouchDB – Replication



    One of the most important features of PouchDB is replication, i.e. you can make a copy of a database. You can replicate either a PouchDB instance stored locally or a CouchDB instance stored remotely.

    Syntax

    Following is the syntax of replicating a database in PouchDB. Here, a copy of the source database is the target. To this method, you can directly pass the location of source and destination databases in String format, or you can pass objects representing them.

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

    Both the source and targets can be either PouchDB instances or CouchDB instances.

    Replicating LocalDB to CouchDB

    Suppose there is a database with the name sample_database in PouchDB, and it contains 3 documents doc1, doc2, and doc3, having contents as shown below.

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

    Following is an example which makes a copy of the database named sample_database that is stored locally in CouchDB.

    //Requiring the package
    var PouchDB = require(''PouchDB'');
    
    var localdb = ''sample_database
    
    //Creating remote database object
    var remotedb = ''http://localhost:5984/sample_database
    
    //Replicating a local database to Remote
    PouchDB.replicate(localDB, remoteDB);
    console.log ("Database replicated successfully");
    

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

    C:PouchDB_Examples >node Replication_example.js
    

    This makes a copy of the database named sample_database in CouchDB instance and displays a message on the console as shown below.

    Database replicated successfully
    

    You can verify whether the database is replicated in your CouchDB instance by clicking the following link http://127.0.0.1:5984/_utils/index.html.

    On clicking, you can see the list of databases in your CouchDB. You can also observe that a copy of the database sample_database is created here.

    Sample Database

    If you select the replicated database, you can view its contents as shown below.

    Replicated Database

    Replicating CouchDB to PouchDB

    Suppose there is a database with the name Remote_Database in CouchDB and it contains 3 documents, doc1, doc2, and doc3, having contents as shown below.

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

    Following is an example which makes a copy of the database named Remote_Database that is stored in CouchDB in the local storage.

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

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

    C:PouchDB_Examples >node Replication_example2.js
    

    This makes a copy of the database named remote_database in PouchDB instance and displays a message on the console as shown below.

    Database replicated successfully
    

    You can verify whether the database is replicated in your Pouch instance by executing the following code.

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

    If the database is replicated on executing the above code, you will get the contents of the replicated database as shown below.

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

    Khóa học lập trình tại Toidayhoc vừa học vừa làm dự án vừa nhận lương: Khóa học lập trình nhận lương tại trung tâm Toidayhoc

  • Khóa học miễn phí PouchDB – Adding Attachment nhận dự án làm có lương

    PouchDB – Adding Attachment



    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.

    Adding Attachment to a Remote Document

    And if you select the database named my_database, you can view its contents as shown below.

    Adding Attachment

    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.

    Adding Attachment Verification

    Khóa học lập trình tại Toidayhoc vừa học vừa làm dự án vừa nhận lương: Khóa học lập trình nhận lương tại trung tâm Toidayhoc

  • Khóa học miễn phí PouchDB – Synchronization nhận dự án làm có lương

    PouchDB – Synchronization



    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.

    Remote Database

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

    Khóa học lập trình tại Toidayhoc vừa học vừa làm dự án vừa nhận lương: Khóa học lập trình nhận lương tại trung tâm Toidayhoc

  • Khóa học miễn phí PouchDB – Miscellaneous nhận dự án làm có lương

    PouchDB – Miscellaneous



    In this chapter, we will discuss the concepts like, compaction and retrieval of bulk data from PouchDB.

    Compaction

    You can reduce the size of a database by removing the unused data using compact() method. You can compact a local database as well as remote database using this method.

    Following is an example demonstrating the usage of the compact() method 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 Method

    You can retrieve a set of documents in bulk using the bulkGet() method. To this method, you need to pass a set of id’s and _rev’s.

    Following is an example demonstrating the usage of the bulkGet() method 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);
       }
    });
    

    Khóa học lập trình tại Toidayhoc vừa học vừa làm dự án vừa nhận lương: Khóa học lập trình nhận lương tại trung tâm Toidayhoc