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）
  • Chrome 30+
  • Safari 5+
  • Internet Explorer 10+
  • Opera 21+
  • Android 4.0+
  • iOS 7.1+
  • Windows Phone 8+

PouchDB - 环境

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

安装 PouchDB

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

步骤 1

访问 PouchDB 网站的主页，点击以下链接 -

https://PouchDB.com/

PouchDB Homepage

步骤 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

按照我们 CoffeeScript 教程中“安装 Node.js”部分中给出的步骤安装 Node.js。

步骤 2

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

npm install --save PouchDB

下载 CouchDB

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

步骤 1

CouchDB 的官方网站是 https://couchdb.cn。如果您点击提供的链接，您可以获得 CouchDB 官方网站的主页，如下面的屏幕截图所示。

Download CouchDB

步骤 2

如果您点击下载按钮，将转到一个页面，其中提供了各种格式的 CouchDB 下载链接。以下快照说明了这一点。

CouchDB Download Links Formats

步骤 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 界面。

Web Interface

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('https://127.0.0.1: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: 'https://127.0.0.1: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 中的数据库列表，您将获得以下屏幕截图。

Deleting Remote Database

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

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

//Creating the database object
var db = new PouchDB('https://127.0.0.1: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

验证

执行上述程序后，如果您再次访问该 URL，您将获得以下屏幕截图。在这里，您可以观察到只有两个数据库，因为my_database已被删除。

Delete Database Verification

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 中的数据库列表，您将获得以下屏幕截图。

Inserting a Document in a Remote Database

现在，如果您点击名为my_database的数据库，您会发现一个空数据库，如下面的屏幕截图所示。

Empty Database

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

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

//Creating the database object
var db = new PouchDB('https://127.0.0.1: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，您可以观察到创建的文档，如下面的屏幕截图所示。

Remote Database Verification

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中的数据库列表，您将获得以下屏幕截图。

Reading a Document from a Remote Database

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

Reading a Document

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

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

//Creating the database object
var db = new PouchDB('https://127.0.0.1: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

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

{ 
   _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 中的数据库列表，您将获得以下屏幕截图。

Updating a Document in a Remote Database

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

Updating Database

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

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

//Creating the database object
var db = new PouchDB('https://127.0.0.1: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 中的数据库列表，您将获得以下屏幕截图。

Deleting a Document from a Remote Database

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

Deleting Database

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

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

//Creating the database object
var db = new PouchDB('https://127.0.0.1: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

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

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 中的数据库列表，您将获得以下屏幕截图。

Inserting a Batch in a Remote Database

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

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

//Creating the database object
var db = new PouchDB('https://127.0.0.1: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

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

Document created Successfully

验证

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

Inserting Batch Verification

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设置为true，如下所示。

//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 中的数据库列表，您将获得以下屏幕截图。

Reading a Batch from a Remote Database

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

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

//Creating the database object
var db = new PouchDB('https://127.0.0.1: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以及要更新的值。

假设名为my_database的数据库本地存储在PouchDB中，包含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

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

[ 
   { 
      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 中的数据库列表，您将获得以下屏幕截图。

Updating Batch from a Remote Database

并假设我们选择名为my_database的数据库，您会发现它包含3个文档，如下面的屏幕截图所示。

Updating Batch

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

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

//Creating the database object
var db = new PouchDB('https://127.0.0.1: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('https://127.0.0.1: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。

假设名为my_database的数据库本地存储在PouchDB中，包含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 中的数据库列表，您将获得以下屏幕截图。

Deleting Batch from a Remote Database

如果我们选择名为my_database的数据库，您会发现它包含3个文档，如下面的屏幕截图所示。

Deleting Batch

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

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

//Creating the database object
var db = new PouchDB('https://127.0.0.1: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或buffer对象准备附件，其中blob用于与浏览器交互，而buffer用于与Node.js交互，因为我们在Node.js中演示程序，所以我们使用buffer对象来准备文档。

示例

以下是在PouchDB中使用putAttachment()方法在名为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

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

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数据库中有一个名为“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 中的数据库列表，您将获得以下屏幕截图。

Adding Attachment to a Remote Document

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

Adding Attachment

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

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

//Creating the database object
var db = new PouchDB('https://127.0.0.1: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

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

Adding Attachment Verification

PouchDB - 获取附件

您可以使用PouchDB中的getAttachment()方法检索附件。此方法始终返回blob或buffer对象。

语法

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

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

示例

以下是从PouchDB中检索文档附件的示例，使用getAttachment()方法。使用此代码，我们尝试从文档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 中的数据库列表，您将获得以下屏幕截图。

Retrieving Attachment from a Remote Document

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

Retrieving Attachment

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

Attachment

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

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

//Creating the database object 
var db = new PouchDB('https://127.0.0.1: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 - 删除附件

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

语法

以下是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' 
}

以下是在PouchDB中使用removeAttachment()方法删除此文档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 中的数据库列表，您将获得以下屏幕截图。

Removing Attachment from a Remote Document

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

Removing Attachment Database

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

Removing Attachment

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

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

//Creating the database object 
var db = new PouchDB('https://127.0.0.1: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

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

Attachment Deleted

PouchDB - 复制

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

语法

以下是PouchDB中复制数据库的语法。此处，源数据库的副本是目标。对于此方法，您可以直接以字符串格式传递源数据库和目标数据库的位置，或者您可以传递表示它们的object。

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

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

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

var localdb = 'sample_database';

//Creating remote database object 
var remotedb = 'https://127.0.0.1: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的副本。

Sample Database

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

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

以下是一个示例，它将在本地存储中复制存储在CouchDB中的名为Remote_Database的数据库。

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

var localdb = 'sample_database';

var remotedb = 'https://127.0.0.1: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'}

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

//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('https://127.0.0.1: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）已复制到此数据库中，如下所示。

Remote Database

同样，如果您获取存储在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()方法重写上述程序，而不是使用replicate.to()和replicate.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('https://127.0.0.1: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方法

您可以使用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);
   }
});
打印页面
上一页
下一页
广告