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 的官方網站是 http://couchdb.apache.org。如果您點選提供的連結，您可以獲得 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://: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://: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://: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://: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://: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://: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://: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://: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://: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://: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://: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://: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://: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://: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://: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://: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://: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://: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://: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);
   }
});
列印頁面
上一頁
下一頁
廣告