PouchDB – 快速指南

PouchDB – 快速指南

PouchDB – 概述

本章简要介绍了 PouchDB 及其功能和工作原理。

什么是 PouchDB？

PouchDB 是一个用 JavaScript 编写的开源浏览器内数据库 API。它以Couch DB为模型，减去 NoSQL 数据库。使用这个 API，我们可以构建离线和在线工作的应用程序。它内部使用 WebSQL 和 IndexedDB 来存储数据。

它是如何工作的？

在 PouchDB 中，当应用程序离线时，在浏览器中使用 WebSQL 和 IndexedDB 将数据存储在本地。当应用程序重新上线时，它会与 CouchDB 和兼容服务器同步。

使用 PouchDB，您可以无缝地与本地和远程数据库通信，而不会注意到任何区别。

PouchDB 的特点

以下是 PouchDB 的功能 –

  • 跨浏览器– PouchDB 提供的 API 在每个环境中都相同，因此，我们可以在各种浏览器中运行 PouchDB 应用程序。

  • 轻量级– PouchDB 是一个非常轻量级的 API，只需使用脚本标签即可轻松包含它。

  • 易于学习– 如果您有任何编程语言的先验知识，则学习 PouchDB 很容易。

  • 开源– PouchDB 是一个开源应用程序，可在 GitHub 上获得。

PouchDB 的优势

以下是 PouchDB 的优点 –

  • 由于 PouchDB 驻留在浏览器中，因此无需通过网络执行查询，这会加快查询的执行速度。

  • 您可以将数据与任何受支持的服务器同步，这样您就可以在线和离线运行应用程序。

支持 PouchDB 的浏览器

以下是支持 PouchDB 的浏览器 –

  • Firefox 29+（包括 Firefox OS 和 Firefox for Android）
  • 铬 30+
  • Safari 5+
  • Internet Explorer 10+
  • 歌剧21+
  • 安卓4.0+
  • iOS 7.1+
  • Windows Phone 8+

PouchDB – 环境

本章介绍如何在您的系统中下载和安装 PouchDB。

安装 PouchDB

为了使用 PouchDB，您需要下载文件.js文件并将其包含在您的脚本中。以下是安装 PouchDB 的步骤。

步骤1

通过单击以下链接访问 PouchDB 网站的主页 –

https://PouchDB.com/

PouchDB 主页

第2步

单击网页右上角的下载按钮，如上图所示。这将在您的系统中下载PouchDB-5.3.0.min.js。

第 3 步

将PouchDB-5.3.0.min.js复制并粘贴到您的工作目录，并将其包含在您的 JavaScript 中，如以下命令所示。

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

使用 Node.js 安装 Pouch

您还可以将 PouchDB 安装为 Node.js 模块。以下是使用 Node.js 安装 PouchDB 的步骤。

步骤1

按照我们的咖啡脚本教程的安装 Node.js 部分中给出的步骤安装 Node.js。

第2步

打开命令提示符并执行以下命令。这将在您的系统中安装 PouchDB 节点模块。

npm install --save PouchDB

下载 CouchDB

离线时，PouchDB 将数据存储在本地并像应用程序一样工作。您可以通过连接兼容的服务器在线访问它。我们知道 PouchDB 可以连接到 CouchDB，所以，让我们也安装 CouchDB。以下是安装 CouchDB 的步骤。

步骤1

CouchDB 的官方网站是http://couchdb.apache.org。如果单击给定的链接，您可以获取 CouchDB 官方网站的主页，如下面的屏幕截图所示。

下载 CouchDB

第2步

如果您单击下载按钮，将打开一个页面，其中提供了各种格式的 CouchDB 下载链接。以下快照说明了相同的情况。

CouchDB 下载链接格式

第 3 步

选择 Windows 系统的下载链接，然后选择提供的镜像之一开始下载。

安装 CouchDB

Windows 可执行文件setup-couchdb-1.6.1_R16B02.exe文件将下载到您的系统上。运行安装文件并继续安装。

在系统中成功安装 CouchDB 后，打开 CouchDB 的安装文件夹，进入 bin 文件夹，并通过运行名为couchdb.bat的脚本文件启动服务器。

安装后，通过访问以下链接打开 CouchDB 的内置 Web 界面 – http://127.0.0.1:5984/。如果一切顺利，这将为您提供一个网页，该网页将具有以下输出。

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

您可以使用以下 URL 与 CouchDB Web 界面进行交互 –

http://127.0.0.1:5984/_utils/

这显示了 Futon 的索引页面，它是 CouchDB 的 Web 界面。

网页界面

PouchDB – 创建数据库

您可以使用 PouchDB 构造函数在 PouchDB 中创建数据库。

句法

以下是使用 PouchDB 构造函数的语法。为此，您需要将数据库的名称作为参数传递。

new PouchDB(Database_name)

例子

要使用node在 PouchDB 中创建数据库，首先，您需要使用require()方法要求 PouchDB 包，然后您可以创建一个数据库，如下例所示。

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

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

将上述代码保存在名为Create_Database.js的文件中。打开命令提示符并使用node执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples>node Create_Database.js

这将在本地创建一个数据库（您可以看到当前目录中的文件夹），显示以下消息。

Database created Successfully.

PouchDB – 数据库信息

您可以使用名为info()的方法获取有关数据库的基本信息

句法

以下是使用PouchDB的info()方法的语法。此方法接受回调函数。

db.info([callback])

例子

以下是使用info()方法检索数据库信息的示例。在这里，我们显示名为my_database的数据库的信息。如果出现错误，错误将显示在控制台上。

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

将上述代码保存在名为Database_info.js的文件中。打开命令提示符并使用node执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples>node Database_info.js

这将显示指定数据库的信息，如下所示。

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

远程数据库信息

以同样的方式，您可以获取远程保存在服务器（CouchDB）上的数据库的信息。为此，您需要将路径传递到 CouchDB 中所需的数据库，而不是数据库名称。

例子

以下是检索保存在 CouchDB 服务器中的数据库信息的示例。此代码为您提供名为my_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);
   }
});

将上述代码保存在名为Database_Remote_info.js 的文件中。打开命令提示符并使用node执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples>node Database_Remote_info.js

这将显示指定数据库的信息，如下所示。

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

PouchDB – 删除数据库

您可以使用db.destroy()方法删除 PouchDB 中的数据库。

句法

以下是使用db.destroy()方法的语法。该方法接受一个回调函数作为参数。

db.destroy()

例子

以下是使用destroy()方法在 PouchDB 中删除数据库的示例。在这里，我们将删除在前几章中创建的名为my_database的数据库。

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

将上述代码保存在名为Delete_Database.js的文件中。打开命令提示符并使用node执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Delete_Database.js

这将删除名为my_database的数据库，该数据库存储在本地并显示以下消息。

Database Deleted

删除远程数据库

同样，您可以删除远程存储在服务器 (CouchDB) 上的数据库。

为此，您需要在 CouchDB 中将路径传递到需要删除的数据库，而不是数据库名称。

例子

假设在 CouchDB 服务器中有一个名为my_database的数据库。然后，如果您使用 URL http://127.0.0.1:5984/_utils/index.html验证 CouchDB 中的数据库列表，您将获得以下屏幕截图。

删除远程数据库

以下是删除保存在 CouchDB 服务器中的名为my_database的数据库的示例。

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

将上述代码保存在名为Remote_Database_Delete.js的文件中。打开命令提示符并使用node执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >Remote_Database_Delete.js

这将从显示以下消息的 PouchDB 中删除指定的数据库。

Database Deleted

确认

执行上述程序后，如果再次访问该网址，将得到如下截图。由于my_database被删除，在这里您只能观察到两个数据库。

删除数据库验证

PouchDB – 创建文档

您可以使用db.put()方法在 PouchDB 中创建文档。

句法

以下是使用 PouchDB 的 db.put() 方法的语法。您可以将要在 PouchDB 中创建的文档存储在一个变量中，并作为参数传递给该方法。此外，该方法还接受一个回调（可选）函数作为参数。

db.put(document, callback)

例子

以下是使用put()方法在 PouchDB 中创建文档的示例。我们创建的文档应该是 JSON 格式，一组由逗号 ( , )分隔并括在花括号 ( {} )内的键值对。

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

将上述代码保存在名为Create_Document.js的文件中。打开命令提示符并使用node执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Create_Document.js

这会在名为my_database 的PouchDB 数据库中创建给定的文档，该数据库存储在本地，并显示以下消息。

Document created Successfully

在远程数据库中插入文档

您还可以在远程存储在服务器 (CouchDB) 上的数据库中插入文档。

为此，您需要将路径传递到要在 CouchDB 中创建文档的数据库的路径，而不是数据库名称。

例子

假设在 CouchDB 服务器中有一个名为my_database的数据库。然后，如果您使用 URL http://127.0.0.1:5984/_utils/index.html验证 CouchDB 中的数据库列表，您将获得以下屏幕截图。

在远程数据库中插入文档

现在，如果您单击名为my_database的数据库，您将找到一个空数据库，如下面的屏幕截图所示。

空数据库

以下是在 CouchDB 服务器中保存的名为my_database的数据库中插入文档的示例。

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

将上述代码保存在名为Remote_Create_Document.js的文件中。打开命令提示符并使用node执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Remote_Create_Document.js

这将在名为my_database 的PouchDB 数据库中创建给定的文档，该数据库存储在 CouchDB 中，显示以下消息。

Document created Successfully

确认

执行上述程序后，如果再次访问my_database，可以观察到创建的文档如下图所示。

远程数据库验证

PouchDB – 读取文档

您可以使用db.get()方法在 PouchDB 中读取/检索文档的内容。

句法

以下是使用PouchDB的db.get()方法的语法。此方法接受文档 ID和可选的回调函数。

db.get(document, callback)

例子

以下是使用get()方法读取 PouchDB 中文档内容的示例。

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

将上述代码保存在名为Read_Document.js的文件中。打开命令提示符并使用 node 执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Read_Document.js

这会读取存在于本地存储的名为my_database的数据库中的给定文档的内容。以下消息将显示在控制台上。

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

从远程数据库读取文档

您还可以从远程存储在服务器 (CouchDB) 上的数据库中读取文档。

为此，您需要将路径传递到 CouchDB 中包含要读取的文档的数据库的路径，而不是数据库名称。

例子

假设在 CouchDB 服务器中有一个名为my_database的数据库。然后，如果您使用 URL http://127.0.0.1:5984/_utils/index.html验证 CouchDB 中的数据库列表，您将获得以下屏幕截图。

从远程数据库读取文档

通过单击名为my_database的数据库，您可以看到以下屏幕截图。在这里，您可以观察到该数据库包含一个 ID 为001的文档。

阅读文档

以下是读取存储在 CouchDB 服务器中名为my_database的数据库中存在的id 为“ 001 ”的文档内容的示例。

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

将上述代码保存在名为Remote_Read_Document.js的文件中。打开命令提示符并使用node执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Remote_Read_Document.js

这读取存在于名为my_database的数据库中的给定文档的内容，该数据库存储在 CouchDB 中。控制台上显示以下消息。

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

PouchDB – 更新文档

每当我们在 PouchDB 中创建一个文档时，都会生成一个新字段_rev，它被称为修订标记。该_rev的价值是一种独特的随机数，每次我们修改的值文档时_rev改变。

您可以使用(_rev)更新 PouchDB 中的现有文档。为此，首先检索我们要更新的文档的_rev值。现在，将要更新的内容连同检索到的_rev值放在一个新文档中，最后使用put()方法将该文档插入到 PouchDB 中。

例子

假设我们在 PouchDB 中有一个 id 为001的文档，其中包含一个人的详细信息。为了更新这个文件，我们应该有它的版本号。因此，要检索文档的内容，请使用以下代码。

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

执行上述代码后，您将收到以下输出。

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

现在，使用_rev可以将键“ age ”的值更新为 26，如以下代码所示。

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

将上述代码保存在名为Update_Document.js的文件中。打开命令提示符并使用node执行 JavaScript 文件，如下所示。

C:\Pouch_Examples>node Update_Document.js

这将更新存在于本地存储的名为my_database的数据库中的给定文档的内容。控制台上显示以下消息。

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

更新远程数据库中的文档

您还可以更新远程存储在服务器 (CouchDB) 上的数据库中的现有文档。

为此，您需要将路径传递到 CouchDB 中包含要更新的文档的数据库的路径，而不是数据库名称。

例子

假设在 CouchDB 服务器中有一个名为my_database的数据库。然后，如果您使用 URL http://127.0.0.1:5984/_utils/index.html验证 CouchDB 中的数据库列表，您将获得以下屏幕截图。

更新远程数据库中的文档

通过单击名为my_database的数据库，您可以看到以下屏幕截图。在这里，您可以观察到该数据库包含一个 ID 为001的文档。

更新数据库

以下是更新存储在 CouchDB 服务器中名为my_database的数据库中存在的id 为“ 001 ”的文档的年龄的示例。

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

将上述代码保存在名为Remote_Update_Document.js的文件中。打开命令提示符并使用node执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Remote_Update_Document.js

这将更新存储在 CouchDB 中名为my_database的数据库中存在的给定文档的内容。控制台上显示以下消息。

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

PouchDB – 删除文档

您可以使用db.remove()方法从 PouchDB 中存在的数据库中删除文档。

句法

以下是使用PouchDB的db.remove()方法的语法。对于此方法，我们必须传递id和_rev以删除现有文档，如下面的代码所示。此方法接受一个可选的回调函数。我们也可以传递完整的文档而不是 id 和 _rev。

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

例子

假设我们在 PouchDB 中有一个 id 为001的文档，其中包含一个人的详细信息。为了删除这个文档连同它的id，我们还应该有它的_rev编号。因此，检索文档的内容，如以下代码所示。

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

执行上面的代码给出以下输出。

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

现在，使用文档的_rev和 id，您可以使用remove()方法删除它，如下面的代码所示。

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

将上述代码保存在名为Delete_Document.js的文件中。打开命令提示符并使用node执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Delete_Document.js

这将删除存在于本地存储的名为my_database的数据库中的给定文档的内容。显示以下消息。

Document deleted successfully

从远程数据库中删除文档

您还可以从远程存储在服务器 (CouchDB) 上的数据库中删除现有文档。

为此，您需要将路径传递到 CouchDB 中包含要读取的文档的数据库的路径，而不是数据库名称。

例子

假设在 CouchDB 服务器中有一个名为my_database的数据库。然后，如果您使用 URL http://127.0.0.1:5984/_utils/index.html验证 CouchDB 中的数据库列表，您将获得以下屏幕截图。

从远程数据库中删除文档

通过单击名为my_database的数据库，您可以看到以下屏幕截图。在这里，您可以观察到数据库包含一个 ID 为001的文档。

删除数据库

以下是删除存储在 CouchDB 服务器中名为my_database的数据库中存在的id 为“ 001 ”的文档内容的示例。

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

将上述代码保存在名为Remote_Delete_Document.js的文件中。打开命令提示符并使用node执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Remote_Delete_Document.js

这将删除名为my_database的数据库中存在的给定文档，该数据库存储在 CouchDB 中。显示以下消息。

Document deleted successfully

PouchDB – 创建批次

您可以使用db.bulkDocs()方法在 PouchDB 中创建文档数组（批处理）。在创建文档时，如果我们不提供 _id 值，则使用此方法，PouchDB 会代表我们为所有文档批量生成唯一 ID。

句法

以下是使用PouchDB的db.bulkDocs()方法的语法。您可以将所有要在 PouchDB 中创建的文档存储在一个数组中，并将其作为参数传递给该方法。除此之外，该方法还接受一个回调（可选）函数作为参数。

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

例子

以下是使用db.bulkDocs()方法在 PouchDB 中创建多个文档的示例。我们创建的文档应该是 JSON 格式，一组由逗号 ( , )分隔并用大括号 ( {} )括起来的键值对。

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

将上述代码保存在名为Create_Batch.js的文件中。打开命令提示符并使用node执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Create_Batch.js

这会在名为my_database 的PouchDB 数据库中创建给定的文档，该数据库存储在本地。将显示以下消息。

Documents created Successfully

在远程数据库中插入批处理

您可以在远程存储在服务器 (CouchDB) 上的数据库中插入一组文档。

为此，您需要将路径传递到我们要在 CouchDB 中创建文档的数据库的路径，而不是数据库名称。

例子

假设在 CouchDB 服务器中有一个名为my_database的数据库。然后，如果您使用 URL http://127.0.0.1:5984/_utils/index.html验证 CouchDB 中的数据库列表，您将获得以下屏幕截图。

在远程数据库中插入批处理

以下是在名为my_database的数据库中插入文档数组的示例，该数据库保存在 CouchDB 服务器中。

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

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

//Preparing the documents array

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

docs = [doc1, doc2, doc3]

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

将上述代码保存在名为Remote_Create_Batch.js的文件中。打开命令提示符并使用node执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Remote_Create_Batch.js

这会在名为my_database 的PouchDB 数据库中创建给定的文档，该数据库存储在 CouchDB 中。显示以下消息。

Document created Successfully

确认

执行上述程序后，如果再次访问my_database，可以观察到创建的文档，如下面的屏幕截图所示。

插入批量验证

PouchDB – 获取批处理

您可以使用allDocs()方法从 PouchDB 中的数据库读取/检索多个/批量文档。

句法

以下是使用PouchDB的db.allDocs()方法的语法。此方法接受一个可选的回调函数。

db.allDocs()

例子

以下是使用db.allDocs()方法检索本地存储的名为my_database的数据库中的所有文档的示例。此方法以对象的形式检索文档数组，以获取您需要调用为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);
   }
});

将上述代码保存在名为Read_All_Document.js的文件中。打开命令提示符并使用node执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Read_All_Document.js

这将读取名为my_database的数据库中存在的所有文档，该数据库存储在本地。控制台上显示以下消息。

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

一般来说，如上面的结果所示，使用allDocs()方法只能看到每个文档的_id、key和_rev字段。但是，要在结果中包含整个文档，您必须使可选参数include_docs 为真，如下所示。

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

执行上面的代码会给你一个指定文档中完整文档的列表，如下面的代码所示。

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

从远程数据库读取批次

您还可以从远程存储在服务器 (CouchDB) 上的数据库中获取所有文档。

要这样做而不是数据库名称，您需要将路径传递到 CouchDB 中的数据库，其中包含要读取的文档。

例子

假设在 CouchDB 服务器中有一个名为my_database的数据库。然后，如果您使用 URL http://127.0.0.1:5984/_utils/index.html验证 CouchDB 中的数据库列表，您将获得以下屏幕截图。

从远程数据库读取批次

以下是读取存储在 CouchDB 服务器中名为my_database的数据库中存在的所有文档的示例。

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

将上述代码保存在名为Remote_Read_AllDocument.js的文件中。打开命令提示符并使用node执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Remote_Read_AllDocument.js

这将读取存储在 CouchDB 中名为my_database的数据库中存在的给定文档的内容，并显示在控制台上，如下所示。

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

PouchDB – 更新批次

您可以使用bulkDocs()方法一次更新 PouchDB 中的文档数组。为此，您需要创建一个文档数组，其中每个文档都包含_id、_rev和要更新的值。

假设本地存储在 PouchDB 中名为my_database的数据库包含 3 个文档，即 doc1、doc2、doc3，其内容如下。

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

假设我们必须将所有 3 个文档中的年龄值增加 2 年。为此，首先您需要获取_rev值。因此，使用以下代码获取这些文档的内容。

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

将上面的代码保存为bulk_fetch.js。执行时，上述程序为您提供数据库中文档的 _id 和 _rev 值，如下所示。

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

现在，您可以使用各自的_id和_rev值更新文档，如下所示。

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

将上述代码保存在名为Update_All_Document.js的文件中。打开命令提示符并使用 node 执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Update_All_Document.js

这将更新名为my_database的数据库中存在的所有文档，该数据库存储在本地，并显示以下消息。

Documents Updated Successfully

现在，如果您通过在allDocs()函数中添加{include_docs: true}作为参数来执行bulk_fetch.js程序，则在回调之前，您将看到更新的文档值，如下所示。

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

从远程数据库更新批处理

您可以更新远程存储在服务器 (CouchDB) 上的数据库中的所有文档。

为此，您需要将路径传递到 CouchDB 中包含要读取的文档的数据库的路径，而不是数据库名称。

例子

假设在 CouchDB 服务器中有一个名为my_database的数据库。然后，如果您使用 URL http://127.0.0.1:5984/_utils/index.html验证 CouchDB 中的数据库列表，您将获得以下屏幕截图。

从远程数据库更新批处理

假设我们选择名为my_database的数据库，您可以观察到它包含 3 个文档，如下面的屏幕截图所示。

更新批次

现在，使用以下代码获取这些文档的内容。

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

将上述代码另存为remote_bulk_fetch.js。执行时，上述程序为您提供数据库中所有文档的内容，如下所示。

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

以下是更新存储在 CouchDB 服务器中名为my_database的数据库中存在的所有文档的示例。

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

将上述代码保存在名为Remote_Update_Document.js的文件中。打开命令提示符并使用 node 执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Remote_Update_Document.js

这将更新存储在 CouchDB 中名为my_database的数据库中存在的所有给定文档的内容，并显示以下消息。

Documents Updated Successfully

现在，如果您执行remote_bulk_fetch.js程序，您将看到更新的文档值，如下所示。

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

PouchDB – 删除批次

您可以使用bulkDocs()方法一次删除 PouchDB 中的一组文档。为此，您需要创建一组要删除的文档，其中每个文档应包含_id和_rev。除了这些，您还必须添加另一个键值对_deleted: true。

假设本地存储在 PouchDB 中名为my_database的数据库包含 3 个文档，即 doc1、doc2、doc3，其内容如下。

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

比如说，我们必须删除所有三个文件。然后，首先您需要获取它们的_rev值。因此，使用以下代码获取这些文档的内容。

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

将上面的代码保存为bulk_fetch.js。执行上述程序，您将获得数据库中文档的 _id 和 _rev 值，如下所示。

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

现在，您可以使用各自的_id和_rev值删除文档，如下所示。

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

将上述代码保存在名为Delete_All_Document.js的文件中。打开命令提示符并使用 node 执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Delete_All_Document.js

这将删除本地存储的名为my_database的数据库中存在的所有文档，并显示以下消息。

Documents Deleted Successfully

现在，如果您执行bulk_fetch.js程序，您可以在控制台上观察到一个空大括号，表示数据库为空，如下所示。

[]

从远程数据库中删除批次

您可以更新远程存储在服务器 (CouchDB) 上的数据库中的所有文档。

为此，您需要将路径传递到 CouchDB 中包含要读取的文档的数据库的路径，而不是数据库名称。

例子

假设在 CouchDB 服务器中有一个名为my_database的数据库。然后，如果您使用 URL http://127.0.0.1:5984/_utils/index.html验证 CouchDB 中的数据库列表，您将获得以下屏幕截图。

从远程数据库中删除批次

如果我们选择名为my_database的数据库，您可以观察到它包含 3 个文档，如下面的屏幕截图所示。

删除批次

以下是删除存储在 CouchDB 服务器中名为my_database的数据库中存在的所有文档的示例。

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

将上述代码保存在名为Remote_delete_AllDocuments.js的文件中。打开命令提示符并使用 node 执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Remote_Delete_AllDocuments.js

这将删除存储在 CouchDB 中名为my_database的数据库中存在的所有给定文档的内容，并显示以下消息。

Documents Deleted Successfully

PouchDB – 添加附件

您可以使用PouchDB 中的putAttachment()方法将二进制对象附加到文档。

句法

以下是putAttachment()的语法。对于此方法，我们必须将文档 id、附件 id、MIME 类型与附件一起传递。此方法还接受一个可选的回调函数。

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

我们可以使用 blob 或缓冲区对象准备附件，其中blob在使用浏览器时使用，缓冲区在使用Node.js 时使用，因为我们在 Node.js 中演示我们的程序，所以我们使用缓冲区对象来准备文档。

例子

以下是使用putAttachment()方法在 PouchDB 中名为my_database的数据库中创建带有附件的文档的示例。

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

将上述代码保存在名为Add_Attachment.js的文件中。打开命令提示符并使用node执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Add_Attachment.js

这会在名为my_database的数据库中创建一个向其添加附件的空文档，该数据库存储在 PouchDB 中，并显示以下消息。

Attachment added successfully

您可以使用以下代码通过阅读文档来验证是否添加了附件。

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

将上述代码另存为read_doc.js并执行。执行这个程序，可以看到文档如下内容。

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

向现有文档添加附件

假设数据库中有一个名为my_database PouchDB 且 ID 为“ 002 ”的文档。您可以通过将 id 值更改为002来执行read_doc.js来获取它的内容，如下所示。

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

现在，您可以使用其_rev值向该文档添加附件。

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

将上述代码保存在名为Add_Attachment_to_doc.js的文件中。打开命令提示符并使用node执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Add_Attachment_to_doc.js

这会向指定的文档添加一个附件，显示以下消息。

Attachment added successfully

如果将read_doc.js 中的 id 值改为002并执行，将会得到如下输出。

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

向远程文档添加附件

您甚至可以向远程存储在服务器 (CouchDB) 上的数据库中现有的文档添加附件。

为此，您需要将路径传递到 CouchDB 中包含要读取的文档的数据库的路径，而不是数据库名称。

例子

假设在 CouchDB 服务器中有一个名为my_database的数据库。然后，如果您使用 URL http://127.0.0.1:5984/_utils/index.html验证 CouchDB 中的数据库列表，您将获得以下屏幕截图。

向远程文档添加附件

如果选择名为my_database的数据库，则可以查看其内容，如下所示。

添加附件

以下是向存储在名为my_database的数据库中的文档001添加附件的示例，该数据库存储在 CouchDB 服务器中。

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

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

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

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

将上述代码保存在名为Remote_Add_Attachment.js的文件中。打开命令提示符并使用node执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Remote_Add_Attachment.js

这会向指定的文档添加一个附件，显示以下消息。

Attachment added successfully

现在，如果您验证文档，您可以观察添加到其中的附件，如下面的屏幕截图所示。

添加附件验证

PouchDB – 检索附件

您可以使用getAttachment()方法从 PouchDB 检索附件。此方法始终返回 blob 或缓冲区对象。

句法

以下是getAttachment()的语法。对于此方法，我们必须传递文档 id 和附件 id。此方法还接受一个可选的回调函数。

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

例子

以下是使用getAttachment()方法检索存储在 PouchDB 中的文档附件的示例。使用此代码，我们尝试从文档001 中检索附件att_1.txt。

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

将上述代码保存在名为Retrieve_Attachment.js的文件中。打开命令提示符并使用node执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Retrieve_Attachment.js

这将检索文档的附件并显示在控制台上，如下所示。

<Buffer 00>

从远程文档中检索附件

您还可以检索远程存储在服务器 (CouchDB) 上的数据库中现有文档的附件。

为此，您需要将路径传递到 CouchDB 中包含要读取的文档的数据库的路径，而不是数据库名称。

例子

假设在 CouchDB 服务器中有一个名为my_database的数据库。然后，如果您使用 URL http://127.0.0.1:5984/_utils/index.html验证 CouchDB 中的数据库列表，您将获得以下屏幕截图。

从远程文档中检索附件

如果选择名为my_database的数据库，则可以查看其内容，如下所示。

检索附件

假设本文档中有一个附件，如下所示。

附件

以下是检索名为my_database的数据库中存在的文档001附件的示例，该数据库存储在 CouchDB 服务器中。

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

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

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

将上述代码保存在名为Remote_Retrieve_Attachment.js的文件中。打开命令提示符并使用node执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Remote_Retrieve_Attachment.js

这将检索文档附件并将其显示在控制台上，如下所示。

<Buffer 00>

PouchDB – 删除附件

您可以使用removeAttachment()方法从 PouchDB 中删除附件。

句法

以下是removeAttachment()方法的语法。对于这个方法，我们必须传递文档 id、附件 id 和 _rev 值。此方法还接受一个可选的回调函数。

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

例子

假设 PouchDB 中有一个 id 为001的文档，其中包含员工的 id、姓名、年龄、职称以及附件，如下所示。

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

以下是使用removeAttachment()方法删除存储在 PouchDB 中的此文档001的附件的示例。

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

将上述代码保存在名为Remove_Attachment.js的文件中。打开命令提示符并使用node执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Remove_Attachment.js

这将删除文档的附件并在控制台上显示一条消息，如下所示。

Attachment deleted successfully

删除后，您可以通过执行以下代码来验证文档的内容。

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

将此代码保存为read.js并执行它。执行时，会得到删除附件后的文档内容，如下图。

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

从远程文档中删除附件

您可以删除远程存储在服务器 (CouchDB) 上的数据库中现有文档的附件。

为此，您需要将路径传递到 CouchDB 中包含要读取的文档的数据库的路径，而不是数据库名称。

例子

假设在 CouchDB 服务器中有一个名为my_database的数据库。然后，如果您使用 URL http://127.0.0.1:5984/_utils/index.html验证 CouchDB 中的数据库列表，您将获得以下屏幕截图。

从远程文档中删除附件

如果选择名为my_database的数据库，则可以查看其内容，如下所示。

删除附件数据库

假设本文档中有一个附件，如下所示。

移除附件

以下是删除存储在 CouchDB 服务器中名为my_database的数据库中存在的文档001 的上述附件的示例。

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

将上述代码保存在名为Remote_Delete_Attachment.js的文件中。打开命令提示符并使用node执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Remote_Delete_Attachment.js

这将删除现有附件并显示以下消息。

Attachment Deleted successfully

如果您再次访问该文档，您会注意到附件已被删除，如下面的屏幕截图所示。

附件已删除

PouchDB – 复制

PouchDB 最重要的功能之一是复制，即您可以制作数据库的副本。您可以复制本地存储的 PouchDB 实例或远程存储的 CouchDB 实例。

句法

以下是在 PouchDB 中复制数据库的语法。在这里，源数据库的副本是目标。对于这个方法，你可以直接以String格式传递源数据库和目标数据库的位置，也可以传递代表它们的对象。

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

源和目标都可以是 PouchDB 实例或 CouchDB 实例。

将 LocalDB 复制到 CouchDB

假设PouchDB中有一个名为sample_database的数据库，包含3个文档doc1、doc2、doc3，内容如下图。

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

下面是一个示例，它制作了一个名为sample_database的数据库的副本，该数据库本地存储在 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");

将上述代码保存在名为Replication_example.js的文件中。打开命令提示符并使用node执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Replication_example.js

这会在 CouchDB 实例中创建名为 sample_database 的数据库的副本，并在控制台上显示一条消息，如下所示。

Database replicated successfully

您可以通过单击以下链接http://127.0.0.1:5984/_utils/index.html来验证是否在您的 CouchDB 实例中复制了数据库。

单击后，您可以看到 CouchDB 中的数据库列表。您还可以观察到此处创建了数据库sample_database的副本。

示例数据库

如果选择复制数据库，则可以查看其内容，如下所示。

复制数据库

将 CouchDB 复制到 PouchDB

假设CouchDB中有一个名为Remote_Database的数据库，它包含3个文档，doc1、doc2和doc3，内容如下所示。

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

下面是一个示例，它创建了一个名为Remote_Database的数据库的副本，该数据库存储在本地存储中的 CouchDB 中。

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

将上述代码保存在名为Replication_example2.js的文件中。打开命令提示符并使用node执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Replication_example2.js

这会在 PouchDB 实例中复制名为remote_database的数据库，并在控制台上显示一条消息，如下所示。

Database replicated successfully

您可以通过执行以下代码来验证数据库是否已复制到您的 Pouch 实例中。

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

如果在执行上述代码时复制了数据库，您将获得复制数据库的内容，如下所示。

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

PouchDB – 同步

您可以将本地存储在 PouchDB 中的数据库与存储在 CouchDB 中的数据库同步。在上一章中，我们已经看到了如何使用 PouchDB 复制数据库。在那里我们使用了PouchDB.replicate(source, destination) 方法。

除此之外，我们还可以使用replicate.to()和replicate.from()方法将数据从本地数据库复制到远程数据库，以及从远程数据库复制到本地数据库，如下所示。

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

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

其中，localDB是本地存储在 PouchDB中的数据库对象，而remoteDB是存储在 CouchDB 中的数据库对象。

例子

假设PouchDB中有一个名为local_database的数据库，它包含3个文档，doc1、doc2和doc3，内容如下图。

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

CouchDB中有一个名为Remote_Database的数据库，它包含2个文档doc1、doc2，内容如下图。

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

以下是同步这两个数据库的示例，其中一个存储在 PouchDB 中，另一个存储在 CouchDB 中，使用replicate.to()和replicate.from()方法。

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

将上述代码保存在名为Synchronising_databases.js的文件中。打开命令提示符并使用node执行 JavaScript 文件，如下所示。

C:\PouchDB_Examples >node Synchronising_databases.js

这将同步两个数据库 remoteDB 和 localDB，并在控制台上显示一条消息，如下所示。

Databases synchronized successfully.

两个数据库同步后访问http://127.0.0.1:5984/_utils/index.html并选择remote_database。可以观察到本地数据库（003、004、005）的文档被复制到了这个数据库中，如下图。

远程数据库

同理，取出PouchDB中local_database的内容，可以看到CouchDB中存储的数据库的文档被复制到了这里。

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

您可以使用PouchDB 提供的sync()方法来重写上面的程序，而不是使用复制.to ()和复制.from ()两个方法，如下所示。

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

在执行上述程序时，它会同步两个数据库，显示以下消息。

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

PouchDB – 杂项

在本章中，我们将讨论从 PouchDB 中压缩和检索批量数据等概念。

压实

您可以通过使用compact()方法删除未使用的数据来减小数据库的大小。您可以使用此方法压缩本地数据库和远程数据库。

下面是一个示例，演示了PouchDB 中compact()方法的用法。

//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()方法批量检索一组文档。对于此方法，您需要传递一组 id 和 _rev。

下面是一个示例，演示了PouchDB中的bulkGet()方法的用法。

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

觉得文章有用？

点个广告表达一下你的爱意吧 ！😁