PouchDB-퀵 가이드

이 장에서는 기능 및 작동 방식과 함께 PouchDB에 대한 간략한 소개를 제공합니다.

PouchDB는 무엇입니까?

PouchDB는 오픈 소스입니다. in-browser database APIJavaScript로 작성되었습니다. 그것은을 모델로 소파 DB 및 minuss; NoSQL 데이터베이스. 이 API를 사용하여 오프라인 및 온라인에서 작동하는 애플리케이션을 구축 할 수 있습니다. 내부적으로 WebSQL 및 IndexedDB를 사용하여 데이터를 저장합니다.

어떻게 작동합니까?

PouchDB에서 애플리케이션이 오프라인 일 때 데이터는 브라우저에서 WebSQL 및 IndexedDB를 사용하여 로컬로 저장됩니다. 애플리케이션이 다시 온라인 상태가되면 CouchDB 및 호환 서버와 동기화됩니다.

PouchDB를 사용하면 차이를 느끼지 않고 로컬 및 원격 데이터베이스와 원활하게 통신 할 수 있습니다.

PouchDB의 특징

다음은 PouchDB의 기능입니다-

  • Cross Browser − PouchDB에서 제공하는 API는 모든 환경에서 동일하게 작동하므로 다양한 브라우저에서 PouchDB 애플리케이션을 실행할 수 있습니다.

  • Light Weight − PouchDB는 매우 가벼운 API이며 스크립트 태그를 사용하여 쉽게 포함됩니다.

  • Easy to Learn − 프로그래밍 언어에 대한 사전 지식이 있으면 PouchDB를 쉽게 배울 수 있습니다.

  • Open Source − PouchDB는 오픈 소스 애플리케이션이며 GitHub에서 사용할 수 있습니다.

PouchDB의 장점

다음은 PouchDB의 장점입니다-

  • PouchDB는 브라우저 내부에 있기 때문에 네트워크를 통해 쿼리를 수행 할 필요가 없으므로 쿼리 실행 속도가 빨라집니다.

  • 지원되는 모든 서버와 데이터를 동기화 할 수 있으며 이렇게하면 온라인과 오프라인 모두에서 앱을 실행할 수 있습니다.

PouchDB를 지원하는 브라우저

다음은 PouchDB를 지원하는 브라우저입니다.

  • Firefox 29 이상 (Firefox OS 및 Android 용 Firefox 포함)
  • Chrome 30 이상
  • Safari 5 이상
  • Internet Explorer 10 이상
  • Opera 21 이상
  • Android 4.0 이상
  • iOS 7.1 이상
  • Windows Phone 8 이상

이 장에서는 시스템에 PouchDB를 다운로드하고 설치하는 방법을 설명합니다.

PouchDB 설치

PouchDB를 사용하려면 파일을 다운로드해야합니다. .js파일을 작성하고 스크립트에 포함하십시오. 다음은 PouchDB를 설치하는 단계입니다.

1 단계

다음 링크를 클릭하여 PouchDB 웹 사이트의 홈페이지를 방문하십시오.

https://PouchDB.com/

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를 사용하여 파우치 설치

PouchDB를 Node.js 모듈로 설치할 수도 있습니다. 다음은 Node.js를 사용하여 PouchDB를 설치하는 단계입니다.

1 단계

커피 스크립트 자습서 의 Node.js 설치 섹션에 제공된 단계에 따라 Node.js를 설치합니다 .

2 단계

명령 프롬프트를 열고 다음 명령을 실행하십시오. 그러면 시스템에 PouchDB 노드 모듈이 설치됩니다.

npm install --save PouchDB

CouchDB 다운로드

오프라인 일 때 PouchDB는 데이터를 로컬에 저장하고 앱처럼 작동합니다. 호환되는 서버에 연결하여 온라인으로 액세스 할 수 있습니다. 우리가 알고 있듯이 PouchDB는 CouchDB에 연결할 수 있으므로 CouchDB도 설치할 수 있습니다. 다음은 CouchDB를 설치하는 단계입니다.

1 단계

CouchDB의 공식 웹 사이트는 http://couchdb.apache.org. 주어진 링크를 클릭하면 다음 스크린 샷과 같이 CouchDB 공식 웹 사이트의 홈페이지를 볼 수 있습니다.

2 단계

다운로드 버튼을 클릭하면 다양한 형식의 CouchDB 다운로드 링크가 제공되는 페이지로 연결됩니다. 다음 스냅 샷은 동일한 것을 보여줍니다.

3 단계

Windows 시스템 용 다운로드 링크를 선택하고 제공된 미러 중 하나를 선택하여 다운로드를 시작하십시오.

CouchDB 설치

Windows 실행 파일 setup-couchdb-1.6.1_R16B02.exe파일이 시스템에 다운로드됩니다. 설치 파일을 실행하고 설치를 계속하십시오.

시스템에 CouchDB를 성공적으로 설치 한 후 CouchDB가 설치된 폴더를 열고 bin 폴더로 이동 한 다음 이름이 지정된 스크립트 파일을 실행하여 서버를 시작하십시오. couchdb.bat.

설치 후 다음 링크를 방문하여 CouchDB의 내장 웹 인터페이스를 엽니 다. 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 웹 인터페이스와 상호 작용할 수 있습니다.

http://127.0.0.1:5984/_utils/

CouchDB의 웹 인터페이스 인 Futon의 인덱스 페이지를 보여줍니다.

PouchDB 생성자를 사용하여 PouchDB에 데이터베이스를 만들 수 있습니다.

통사론

다음은 PouchDB 생성자를 사용하는 구문입니다. 이를 위해 데이터베이스 이름을 매개 변수로 전달해야합니다.

new PouchDB(Database_name)

다음을 사용하여 PouchDB에서 데이터베이스를 생성하려면 node, 먼저 다음을 사용하여 PouchDB 패키지가 필요합니다. require() 다음 예제와 같이 데이터베이스를 만들 수 있습니다.

//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. 명령 프롬프트를 열고 다음을 사용하여 JavaScript 파일을 실행합니다.node 아래 그림과 같이.

C:\PouchDB_Examples>node Create_Database.js

그러면 다음 메시지를 표시하는 데이터베이스가 로컬로 생성됩니다 (현재 디렉터리의 폴더를 볼 수 있음).

Database created Successfully.

다음과 같은 방법을 사용하여 데이터베이스에 대한 기본 정보를 얻을 수 있습니다. info()

통사론

다음은 사용 구문입니다. info()PouchDB의 방법. 이 메서드는 콜백 함수를받습니다.

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. 명령 프롬프트를 열고 다음을 사용하여 JavaScript 파일을 실행합니다.node 아래 그림과 같이.

C:\PouchDB_Examples>node Database_info.js

그러면 다음과 같이 지정된 데이터베이스의 정보가 표시됩니다.

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

원격 데이터베이스 정보

같은 방법으로 서버 (CouchDB)에 원격으로 저장된 데이터베이스의 정보를 얻습니다. 이렇게하려면 데이터베이스 이름 대신 CouchDB에서 필요한 데이터베이스에 대한 경로를 전달해야합니다.

다음은 CouchDB 서버에 저장된 데이터베이스 정보를 검색하는 예입니다. 이 코드는 다음과 같은 데이터베이스에 대한 정보를 제공합니다.my_database.

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

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

//Database information
db.info(function(err, info) {
   if (err) {
      return console.log(err);
   } else {
      console.log(info);
   }
});

위의 코드를 이름을 가진 파일에 저장하십시오. Database_ Remote_info.js. 명령 프롬프트를 열고 다음을 사용하여 JavaScript 파일을 실행합니다.node 아래 그림과 같이.

C:\PouchDB_Examples>node Database_Remote_info.js

그러면 다음과 같이 지정된 데이터베이스의 정보가 표시됩니다.

{ 
   db_name: 'my_database', 
   doc_count: 0, 
   doc_del_count: 0, 
   update_seq: 0, 
   purge_seq: 0, 
   compact_running: false, 
   disk_size: 79, 
   data_size: 0, 
   instance_start_time: '1458209191708486', 
   disk_format_version: 6, 
   committed_update_seq: 0, 
   host: 'http://localhost:5984/my_database/', 
   auto_compaction: false, 
   adapter: 'http' 
}

PouchDB에서 데이터베이스를 삭제할 수 있습니다. db.destroy() 방법.

통사론

다음은 사용 구문입니다. db.destroy()방법. 이 메서드는 콜백 함수를 매개 변수로받습니다.

db.destroy()

다음은 PouchDB에서 데이터베이스를 삭제하는 예제입니다. destroy()방법. 여기에서 이름이 지정된 데이터베이스를 삭제합니다.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. 명령 프롬프트를 열고 다음을 사용하여 JavaScript 파일을 실행합니다. node 아래 그림과 같이.

C:\PouchDB_Examples >node Delete_Database.js

이름이 지정된 데이터베이스가 삭제됩니다. my_database 로컬에 저장되어 다음 메시지를 표시합니다.

Database Deleted

원격 데이터베이스 삭제

같은 방법으로 서버 (CouchDB)에 원격으로 저장된 데이터베이스를 삭제할 수 있습니다.

이렇게하려면 데이터베이스 이름 대신 삭제해야하는 데이터베이스 경로를 CouchDB에 전달해야합니다.

다음과 같은 데이터베이스가 있다고 가정합니다. my_databaseCouchDB 서버에서. 그런 다음 URL을 사용하여 CouchDB의 데이터베이스 목록을 확인하면http://127.0.0.1:5984/_utils/index.html 다음 스크린 샷이 표시됩니다.

다음은 이름이 지정된 데이터베이스를 삭제하는 예입니다. my_database CouchDB 서버에 저장됩니다.

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

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

//deleting database
db.destroy(function (err, response) {
   if (err) {
      return console.log(err);
   } else {
      console.log("Database Deleted");
   }
});

위의 코드를 이름을 가진 파일에 저장하십시오. Remote_Database_Delete.js. 명령 프롬프트를 열고 다음을 사용하여 JavaScript 파일을 실행합니다.node 아래 그림과 같이.

C:\PouchDB_Examples >Remote_Database_Delete.js

이렇게하면 PouchDB에서 지정된 데이터베이스가 삭제되고 다음 메시지가 표시됩니다.

Database Deleted

확인

위의 프로그램을 실행 한 후 URL을 다시 방문하면 다음과 같은 스크린 샷이 나옵니다. 여기서는 두 개의 데이터베이스 만 관찰 할 수 있습니다.my_database 삭제되었습니다.

PouchDB에서 문서를 만들 수 있습니다. db.put() 방법.

통사론

다음은 PouchDB의 db.put () 메소드를 사용하는 구문입니다. PouchDB에 생성 될 문서를 변수에 저장하고이 메소드에 매개 변수로 전달할 수 있습니다. 또한이 메서드는 콜백 (선택 사항) 함수를 매개 변수로 허용합니다.

db.put(document, callback)

다음은 PouchDB에서 문서를 생성하는 예제입니다. put()방법. 우리가 생성하는 문서는 쉼표로 구분 된 키-값 쌍 세트 인 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. 명령 프롬프트를 열고 다음을 사용하여 JavaScript 파일을 실행합니다.node 아래 그림과 같이.

C:\PouchDB_Examples >node Create_Document.js

이렇게하면 PouchDB 데이터베이스에 지정된 문서가 생성됩니다. my_database, 로컬에 저장되고 다음 메시지가 표시됩니다.

Document created Successfully

원격 데이터베이스에 문서 삽입

서버 (CouchDB)에 원격으로 저장된 문서를 데이터베이스에 삽입 할 수도 있습니다.

그렇게하려면 데이터베이스 이름 대신 CouchDB에서 문서를 만들려는 데이터베이스의 경로를 전달해야합니다.

다음과 같은 데이터베이스가 있다고 가정합니다. my_databaseCouchDB 서버에서. 그런 다음 URL을 사용하여 CouchDB의 데이터베이스 목록을 확인하면http://127.0.0.1:5984/_utils/index.html 다음 스크린 샷이 표시됩니다.

이제 데이터베이스를 클릭하면 my_database, 다음 스크린 샷과 같이 빈 데이터베이스를 찾을 수 있습니다.

다음은 이름이 지정된 데이터베이스에 문서를 삽입하는 예입니다. my_database CouchDB 서버에 저장됩니다.

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

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

//Preparing the 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. 명령 프롬프트를 열고 다음을 사용하여 JavaScript 파일을 실행합니다.node 아래 그림과 같이.

C:\PouchDB_Examples >node Remote_Create_Document.js

이렇게하면 PouchDB 데이터베이스에 지정된 문서가 생성됩니다. my_database CouchDB에 저장되며 다음 메시지가 표시됩니다.

Document created Successfully

확인

위 프로그램 실행 후 my_database 다시 다음 스크린 샷과 같이 생성 된 문서를 관찰 할 수 있습니다.

PouchDB에서 문서의 내용을 읽고 검색 할 수 있습니다. db.get() 방법.

통사론

다음은 사용 구문입니다. db.get()PouchDB의 방법. 이 방법은document id 및 선택적 콜백 함수.

db.get(document, callback)

다음은 PouchDB에서 문서 내용을 읽는 예제입니다. get() 방법.

//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. 명령 프롬프트를 열고 아래와 같이 노드를 사용하여 JavaScript 파일을 실행합니다.

C:\PouchDB_Examples >node Read_Document.js

이것은 데이터베이스에 존재하는 주어진 문서의 내용을 읽습니다. my_database로컬에 저장됩니다. 콘솔에 다음 메시지가 표시됩니다.

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

원격 데이터베이스에서 문서 읽기

서버 (CouchDB)에 원격으로 저장된 데이터베이스에서 문서를 읽을 수도 있습니다.

이렇게하려면 데이터베이스 이름 대신 읽을 문서가 포함 된 CouchDB의 데이터베이스 경로를 전달해야합니다.

다음과 같은 데이터베이스가 있다고 가정합니다. my_databaseCouchDB 서버에서. 그런 다음 URL을 사용하여 CouchDB의 데이터베이스 목록을 확인하면http://127.0.0.1:5984/_utils/index.html 다음 스크린 샷이 표시됩니다.

이름이 지정된 데이터베이스를 클릭하여 my_database다음 스크린 샷을 볼 수 있습니다. 여기에서이 데이터베이스에 ID가있는 문서가 있음을 확인할 수 있습니다.001.

다음은 ID가 ""인 문서의 내용을 읽는 예입니다.001"라는 이름의 데이터베이스에 존재하는 my_database, CouchDB 서버에 저장됩니다.

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

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

//Reading the contents of a document
db.get('001', function(err, doc) {
   if (err) {
      return console.log(err);
   } else {
      console.log(doc);
   }
});

위의 코드를 이름을 가진 파일에 저장하십시오. Remote_Read_Document.js. 명령 프롬프트를 열고 다음을 사용하여 JavaScript 파일을 실행합니다.node 아래 그림과 같이.

C:\PouchDB_Examples >node Remote_Read_Document.js

이것은 데이터베이스에 존재하는 주어진 문서의 내용을 읽습니다. my_databaseCouchDB에 저장됩니다. 콘솔에 다음 메시지가 표시됩니다.

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

언제나 새로운 필드 인 PouchDB에 문서를 생성합니다. _rev 생성되고 다음과 같이 알려져 있습니다. revision marker. 그만큼_rev의 값은 고유 한 난수이며 문서를 변경할 때마다 _rev 변경됩니다.

다음을 사용하여 PouchDB의 기존 문서를 업데이트 할 수 있습니다. (_rev). 이렇게하려면 먼저_rev업데이트하려는 문서의 값입니다. 이제 검색된 내용과 함께 업데이트 할 내용을 배치합니다._rev 값을 새 문서에 입력하고 마지막으로이 문서를 PouchDB에 삽입합니다. put() 방법.

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. 명령 프롬프트를 열고 다음을 사용하여 JavaScript 파일을 실행합니다.node 아래 그림과 같이.

C:\Pouch_Examples>node Update_Document.js

이것은 데이터베이스에 존재하는 주어진 문서의 내용을 업데이트합니다. my_database로컬에 저장됩니다. 콘솔에 다음 메시지가 표시됩니다.

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

원격 데이터베이스에서 문서 업데이트

서버 (CouchDB)에 원격으로 저장된 데이터베이스의 기존 문서를 업데이트 할 수도 있습니다.

이렇게하려면 데이터베이스 이름 대신 업데이트 할 문서가 포함 된 CouchDB의 데이터베이스 경로를 전달해야합니다.

다음과 같은 데이터베이스가 있다고 가정합니다. my_databaseCouchDB 서버에서. 그런 다음 URL을 사용하여 CouchDB의 데이터베이스 목록을 확인하면http://127.0.0.1:5984/_utils/index.html 다음 스크린 샷이 표시됩니다.

이름이 지정된 데이터베이스를 클릭하여 my_database, 다음 스크린 샷을 볼 수 있습니다. 여기에서이 데이터베이스에 ID가있는 문서가 있음을 확인할 수 있습니다.001.

다음은 ID가 ""인 문서의 나이를 업데이트하는 예입니다.001"라는 이름의 데이터베이스에 존재하는 my_database CouchDB 서버에 저장됩니다.

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

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

//Preparing the 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. 명령 프롬프트를 열고 다음을 사용하여 JavaScript 파일을 실행합니다.node 아래 그림과 같이.

C:\PouchDB_Examples >node Remote_Update_Document.js

이것은 데이터베이스에 존재하는 주어진 문서의 내용을 업데이트합니다. my_databaseCouchDB에 저장됩니다. 콘솔에 다음 메시지가 표시됩니다.

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

PouchDB에있는 데이터베이스에서 문서를 삭제할 수 있습니다. db.remove() 방법.

통사론

다음은 사용 구문입니다. db.remove()PouchDB의 방법. 이 방법으로, 우리는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. 명령 프롬프트를 열고 다음을 사용하여 JavaScript 파일을 실행합니다.node 아래 그림과 같이.

C:\PouchDB_Examples >node Delete_Document.js

이렇게하면 데이터베이스에 존재하는 주어진 문서의 내용이 삭제됩니다. my_database로컬에 저장됩니다. 다음 메시지가 표시됩니다.

Document deleted successfully

원격 데이터베이스에서 문서 삭제

서버 (CouchDB)에 원격으로 저장된 데이터베이스에서 기존 문서를 삭제할 수도 있습니다.

이렇게하려면 데이터베이스 이름 대신 읽을 문서가 포함 된 CouchDB의 데이터베이스 경로를 전달해야합니다.

다음과 같은 데이터베이스가 있다고 가정합니다. my_databaseCouchDB 서버에서. 그런 다음 URL을 사용하여 CouchDB의 데이터베이스 목록을 확인하면http://127.0.0.1:5984/_utils/index.html 다음 스크린 샷이 표시됩니다.

이름이 지정된 데이터베이스를 클릭하여 my_database다음 스크린 샷을 볼 수 있습니다. 여기에서 데이터베이스에 ID가있는 문서가 있음을 확인할 수 있습니다.001.

다음은 ID가 "인 문서의 내용을 삭제하는 예입니다.001"라는 이름의 데이터베이스에 존재하는 my_database CouchDB 서버에 저장됩니다.

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

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

//Deleting an existing document
db.remove('001', '3-552920d1ca372986fad7b996ce365f5d', function(err) {
   if (err) {
      return console.log(err);
   } else {
      console.log("Document deleted successfully");
   }
});

위의 코드를 이름이있는 파일에 저장하십시오. Remote_Delete_Document.js. 명령 프롬프트를 열고 다음을 사용하여 JavaScript 파일을 실행합니다.node 아래 그림과 같이.

C:\PouchDB_Examples >node Remote_Delete_Document.js

이렇게하면 데이터베이스에 존재하는 주어진 문서가 삭제됩니다. my_databaseCouchDB에 저장됩니다. 다음 메시지가 표시됩니다.

Document deleted successfully

PouchDB에서 문서의 배열 (일괄)을 생성 할 수 있습니다. db.bulkDocs()방법. 문서를 생성하는 동안 _id 값을 제공하지 않으면이 방법을 사용하여 우리를 대신하여 PouchDB는 대량의 모든 문서에 대해 고유 한 ID를 생성합니다.

통사론

다음은 사용 구문입니다. db.bulkDocs()PouchDB의 방법. PouchDB에 생성 될 모든 문서를 배열에 저장하고이 메서드에 매개 변수로 전달할 수 있습니다. 또한이 메서드는 콜백 (선택 사항) 함수를 매개 변수로받습니다.

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

다음은 PouchDB에서 여러 문서를 생성하는 예제입니다. db.bulkDocs ()방법. 우리가 생성하는 문서는 쉼표로 구분 된 키-값 쌍 집합 인 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. 명령 프롬프트를 열고 다음을 사용하여 JavaScript 파일을 실행합니다.node 아래 그림과 같이.

C:\PouchDB_Examples >node Create_Batch.js

이렇게하면 PouchDB 데이터베이스에 지정된 문서가 생성됩니다. my_database로컬에 저장됩니다. 다음 메시지가 표시됩니다.

Documents created Successfully

원격 데이터베이스에 배치 삽입

서버 (CouchDB)에 원격으로 저장된 데이터베이스에 문서 배열을 삽입 할 수 있습니다.

이렇게하려면 데이터베이스 이름 대신 CouchDB에서 문서를 만들려는 데이터베이스 경로를 전달해야합니다.

다음과 같은 데이터베이스가 있다고 가정합니다. my_databaseCouchDB 서버에서. 그런 다음 URL을 사용하여 CouchDB의 데이터베이스 목록을 확인하면http://127.0.0.1:5984/_utils/index.html 다음 스크린 샷이 표시됩니다.

다음은 데이터베이스에 문서 배열을 삽입하는 예입니다. my_database CouchDB 서버에 저장됩니다.

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

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

//Preparing the documents array

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

docs = [doc1, doc2, doc3]

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

위의 코드를 이름을 가진 파일에 저장하십시오. Remote_Create_Batch.js. 명령 프롬프트를 열고 다음을 사용하여 JavaScript 파일을 실행합니다.node 아래 그림과 같이.

C:\PouchDB_Examples >node Remote_Create_Batch.js

이렇게하면 PouchDB 데이터베이스에 지정된 문서가 생성됩니다. my_databaseCouchDB에 저장됩니다. 다음 메시지가 표시됩니다.

Document created Successfully

확인

위 프로그램을 실행 한 후 my_database 다시 다음 스크린 샷과 같이 생성 된 문서를 관찰 할 수 있습니다.

PouchDB의 데이터베이스에서 여러 / 대량 문서를 읽고 / 검색 할 수 있습니다. allDocs() 방법.

통사론

다음은 사용 구문입니다. db.allDocs()PouchDB의 방법. 이 메서드는 선택적 콜백 함수를받습니다.

db.allDocs()

다음은 데이터베이스에있는 모든 문서를 검색하는 예입니다. my_database 로컬에 저장됩니다. db.allDocs()방법. 이 메서드는 호출해야하는 각 문서의 내용을 가져 오기 위해 객체 형식의 문서 배열을 검색합니다.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. 명령 프롬프트를 열고 다음을 사용하여 JavaScript 파일을 실행합니다.node 아래 그림과 같이.

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의 데이터베이스 경로를 전달해야합니다.

다음과 같은 데이터베이스가 있다고 가정합니다. my_databaseCouchDB 서버에서. 그런 다음 URL을 사용하여 CouchDB의 데이터베이스 목록을 확인하면http://127.0.0.1:5984/_utils/index.html 다음 스크린 샷이 표시됩니다.

다음은 이름이 지정된 데이터베이스에있는 모든 문서를 읽는 예입니다. my_database CouchDB 서버에 저장됩니다.

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

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

//Retrieving all the documents in PouchDB
db.allDocs({include_docs: true}, function(err, docs) {
   if (err) {
      return console.log(err);
   } else {
      console.log(docs.rows);
   }
});

위의 코드를 이름을 가진 파일에 저장하십시오. Remote_Read_AllDocument.js. 명령 프롬프트를 열고 다음을 사용하여 JavaScript 파일을 실행합니다.node 아래 그림과 같이.

C:\PouchDB_Examples >node Remote_Read_AllDocument.js

이것은 데이터베이스에 존재하는 주어진 문서의 내용을 읽습니다. my_database CouchDB에 저장되며 아래와 같이 콘솔에 표시됩니다.

[ 
   { 
      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()방법. 이렇게하려면 각 문서에 포함 된 문서 배열을 만들어야합니다._id, _rev 업데이트 할 값입니다.

데이터베이스 이름이 my_database PouchDB에 로컬로 저장되는 파일에는 다음 내용이 포함 된 doc1, doc2, doc3의 3 개 문서가 포함되어 있습니다.

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. 명령 프롬프트를 열고 아래와 같이 노드를 사용하여 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의 데이터베이스 경로를 전달해야합니다.

다음과 같은 데이터베이스가 있다고 가정합니다. my_databaseCouchDB 서버에서. 그런 다음 URL을 사용하여 CouchDB의 데이터베이스 목록을 확인하면http://127.0.0.1:5984/_utils/index.html 다음 스크린 샷이 표시됩니다.

그리고 이름이 지정된 데이터베이스를 선택하면 my_database, 다음 스크린 샷과 같이 3 개의 문서가 포함되어 있음을 알 수 있습니다.

이제 다음 코드를 사용하여 이러한 문서의 내용을 가져옵니다.

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

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

//Retrieving all the documents in PouchDB
db.allDocs({include_docs: true}, function(err, docs) {
   if (err) {
      return console.log(err);
   } else {
      console.log(docs.rows);
   }
});

위 코드를 다른 이름으로 저장 remote_bulk_fetch.js. 실행시 위의 프로그램은 아래와 같이 데이터베이스에있는 모든 문서의 내용을 제공합니다.

[ 
   { 
      id: '001', 
      key: '001', 
      value: { rev: '3-552920d1ca372986fad7b996ce365f5d' }, 
      doc: { 
         _id: '001', 
         _rev: '3-552920d1ca372986fad7b996ce365f5d', 
         name: 'Raju', 
         age: 23, 
         designation: 'Designer' 
      } 
   },
   { 
      id: '002', 
      key: '002', 
      value: { rev: '1-9af15cb11054ebe03a7816bf6c5e4128' }, 
      doc: { 
         _id: '002', 
         _rev: '1-9af15cb11054ebe03a7816bf6c5e4128', 
         name: 'Robert', 
         age: 24, 
         Designation: 'Programmer' 
      } 
   }, 
   { 
      id: '003', 
      key: '003', 
      value: { rev: '1-3033b5a78e915c52fd37325d42eb3935' }, 
      doc: { 
         _id: '003',
         _rev: '1-3033b5a78e915c52fd37325d42eb3935',
         name: 'Rahim', 
         age: 25, 
         Designation: 'Programmer' 
      } 
   } 
]

다음은 이름이 지정된 데이터베이스에있는 모든 문서를 업데이트하는 예입니다. my_database CouchDB 서버에 저장됩니다.

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

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

//Preparing the 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. 명령 프롬프트를 열고 아래와 같이 노드를 사용하여 JavaScript 파일을 실행합니다.

C:\PouchDB_Examples >node Remote_Update_Document.js

이것은 데이터베이스에 존재하는 모든 주어진 문서의 내용을 업데이트합니다. my_database CouchDB에 저장되고 다음 메시지가 표시됩니다.

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()방법. 이렇게하려면 삭제할 문서 배열을 만들어야합니다. 각 문서에는_id_rev. 이 외에도 다른 키-값 쌍을 추가해야합니다._deleted: true.

데이터베이스 이름이 my_database PouchDB에 로컬로 저장되는 파일에는 다음 내용이 포함 된 doc1, doc2, doc3의 3 개 문서가 포함되어 있습니다.

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. 명령 프롬프트를 열고 아래와 같이 노드를 사용하여 JavaScript 파일을 실행합니다.

C:\PouchDB_Examples >node Delete_All_Document.js

이렇게하면 데이터베이스에있는 모든 문서가 삭제됩니다. my_database 로컬에 저장되며 다음 메시지를 표시합니다.

Documents Deleted Successfully

이제 실행하면 bulk_fetch.js 아래에 표시된 것처럼 데이터베이스가 비어 있음을 나타내는 콘솔에서 빈 중괄호를 볼 수 있습니다.

[]

원격 데이터베이스에서 배치 삭제

서버 (CouchDB)에 원격으로 저장된 데이터베이스에서 모든 문서를 업데이트 할 수 있습니다.

이렇게하려면 데이터베이스 이름 대신 읽을 문서가 포함 된 CouchDB의 데이터베이스 경로를 전달해야합니다.

다음과 같은 데이터베이스가 있다고 가정합니다. my_databaseCouchDB 서버에서. 그런 다음 URL을 사용하여 CouchDB의 데이터베이스 목록을 확인하면http://127.0.0.1:5984/_utils/index.html 다음 스크린 샷이 표시됩니다.

이름이 지정된 데이터베이스를 선택하면 my_database, 다음 스크린 샷과 같이 3 개의 문서가 포함되어 있음을 알 수 있습니다.

다음은 이름이 지정된 데이터베이스에있는 모든 문서를 삭제하는 예입니다. my_database CouchDB 서버에 저장됩니다.

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

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

//Preparing the 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. 명령 프롬프트를 열고 아래와 같이 노드를 사용하여 JavaScript 파일을 실행합니다.

C:\PouchDB_Examples >node Remote_Delete_AllDocuments.js

이렇게하면 데이터베이스에 존재하는 모든 주어진 문서의 내용이 삭제됩니다. my_database CouchDB에 저장되고 다음 메시지가 표시됩니다.

Documents Deleted Successfully

다음을 사용하여 문서에 이진 개체를 첨부 할 수 있습니다. putAttachment() PouchDB의 메소드.

통사론

다음은 putAttachment(). 이 방법에는 첨부 파일과 함께 문서 ID, 첨부 ID, MIME 유형을 전달해야합니다. 이 메서드는 선택적 콜백 함수도 허용합니다.

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

Blob 또는 버퍼 개체를 사용하여 첨부 파일을 준비 할 수 있습니다. blob 브라우저로 작업하는 동안 사용되며 buffer 작업하는 동안 사용됩니다 Node.js, Node.js에서 프로그램을 시연하고 있으므로 버퍼 객체를 사용하여 문서를 준비합니다.

다음은 이름이 지정된 데이터베이스 내에서 첨부 파일이있는 문서를 만드는 예입니다. my_database PouchDB에서 putAttachment() 방법.

//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. 명령 프롬프트를 열고 다음을 사용하여 JavaScript 파일을 실행합니다.node 아래 그림과 같이.

C:\PouchDB_Examples >node Add_Attachment.js

이렇게하면 다음과 같은 데이터베이스에 첨부 파일을 추가하는 빈 문서가 생성됩니다. my_database PouchDB에 저장되고 다음 메시지가 표시됩니다.

Attachment added successfully

다음 코드를 사용하여 문서를 읽어 첨부 파일이 추가되었는지 확인할 수 있습니다.

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

//Creating the database object var db = new PouchDB('my_database');

//Reading the Document 
db.get('001',{attachments: true}, function(err, doc) { 
   if (err) { 
      return console.log(err); 
   } else { 
      console.log(doc); 
   } 
});

위 코드를 다른 이름으로 저장 read_doc.js그것을 실행하십시오. 이 프로그램을 실행하면 문서의 다음 내용을 볼 수 있습니다.

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

기존 문서에 첨부 파일 추가

데이터베이스에 이름으로 된 문서가 있다고 가정합니다. my_database ID가 '인 PouchDB002'. 다음을 실행하여 내용을 얻을 수 있습니다.read_doc.js id 값을 다음으로 변경하여 002, 아래 그림과 같이.

{ 
   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. 명령 프롬프트를 열고 다음을 사용하여 JavaScript 파일을 실행합니다.node 아래 그림과 같이.

C:\PouchDB_Examples >node Add_Attachment_to_doc.js

그러면 다음 메시지를 표시하는 첨부 파일이 지정된 문서에 추가됩니다.

Attachment added successfully

ID 값을 변경하면 read_doc.js ...에 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의 데이터베이스 경로를 전달해야합니다.

다음과 같은 데이터베이스가 있다고 가정합니다. my_databaseCouchDB 서버에서. 그런 다음 URL을 사용하여 CouchDB의 데이터베이스 목록을 확인하면http://127.0.0.1:5984/_utils/index.html 다음 스크린 샷이 표시됩니다.

그리고 이름이 지정된 데이터베이스를 선택하면 my_database, 아래와 같이 내용을 볼 수 있습니다.

다음은 문서에 첨부 파일을 추가하는 예입니다. 001 라는 데이터베이스에 저장 my_database CouchDB 서버에 저장됩니다.

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

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

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

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

위의 코드를 이름을 가진 파일에 저장하십시오. Remote_Add_Attachment.js. 명령 프롬프트를 열고 다음을 사용하여 JavaScript 파일을 실행합니다.node 아래 그림과 같이.

C:\PouchDB_Examples >node Remote_Add_Attachment.js

그러면 다음 메시지를 표시하는 첨부 파일이 지정된 문서에 추가됩니다.

Attachment added successfully

이제 문서를 확인하면 다음 스크린 샷과 같이 추가 된 첨부 파일을 볼 수 있습니다.

다음을 사용하여 PouchDB에서 첨부 파일을 검색 할 수 있습니다. getAttachment()방법. 이 메서드는 항상 blob 또는 버퍼 개체를 반환합니다.

통사론

다음은 getAttachment(). 이 방법에는 문서 ID와 첨부 ID를 전달해야합니다. 이 메서드는 선택적 콜백 함수도 허용합니다.

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

다음은 PouchDB에 저장된 문서의 첨부 파일을 검색하는 예입니다. getAttachment()방법. 이 코드를 사용하여 첨부 파일을 검색하려고합니다.att_1.txt 문서에서 001.

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

//Creating the database object
var db = new PouchDB('my_database');

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

위의 코드를 이름을 가진 파일에 저장하십시오. Retrieve_Attachment.js. 명령 프롬프트를 열고 다음을 사용하여 JavaScript 파일을 실행합니다.node 아래 그림과 같이.

C:\PouchDB_Examples >node Retrieve_Attachment.js

이렇게하면 문서의 첨부 파일이 검색되고 아래와 같이 콘솔에 표시됩니다.

<Buffer 00>

원격 문서에서 첨부 파일 검색

서버 (CouchDB)에 원격으로 저장된 데이터베이스에있는 문서의 첨부 파일을 검색 할 수도 있습니다.

이렇게하려면 데이터베이스 이름 대신 읽을 문서가 포함 된 CouchDB의 데이터베이스 경로를 전달해야합니다.

다음과 같은 데이터베이스가 있다고 가정합니다. my_databaseCouchDB 서버에서. 그런 다음 URL을 사용하여 CouchDB의 데이터베이스 목록을 확인하면http://127.0.0.1:5984/_utils/index.html 다음 스크린 샷이 표시됩니다.

이름이 지정된 데이터베이스를 선택하면 my_database, 아래와 같이 내용을 볼 수 있습니다.

이 문서에 아래와 같이 첨부 파일이 있다고 가정합니다.

다음은 문서의 첨부 파일을 검색하는 예입니다. 001 라는 데이터베이스에 존재하는 my_database, CouchDB 서버에 저장됩니다.

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

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

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

위의 코드를 이름을 가진 파일에 저장하십시오. Remote_Retrieve_Attachment.js. 명령 프롬프트를 열고 다음을 사용하여 JavaScript 파일을 실행합니다.node 아래 그림과 같이.

C:\PouchDB_Examples >node Remote_Retrieve_Attachment.js

이렇게하면 문서 첨부 파일이 검색되고 아래와 같이 콘솔에 표시됩니다.

<Buffer 00>

PouchDB에서 첨부 파일을 삭제할 수 있습니다. removeAttachment() 방법.

통사론

다음은 removeAttachment()방법. 이 메서드에는 문서 ID, 첨부 파일 ID 및 _rev 값을 전달해야합니다. 이 메서드는 선택적 콜백 함수도 허용합니다.

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

PouchDB에 ID가있는 문서가 있다고 가정합니다. 001, 직원의 아이디, 이름, 나이, 명칭 및 첨부 파일이 포함되어 있습니다.

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

다음은이 문서의 첨부 파일을 삭제하는 예입니다. 001 PouchDB에 저장, 사용 removeAttachment() 방법.

//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. 명령 프롬프트를 열고 다음을 사용하여 JavaScript 파일을 실행합니다.node 아래 그림과 같이.

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의 데이터베이스 경로를 전달해야합니다.

다음과 같은 데이터베이스가 있다고 가정합니다. my_databaseCouchDB 서버에서. 그런 다음 URL을 사용하여 CouchDB의 데이터베이스 목록을 확인하면http://127.0.0.1:5984/_utils/index.html 다음 스크린 샷이 표시됩니다.

그리고 이름이 지정된 데이터베이스를 선택하면 my_database, 아래와 같이 내용을 볼 수 있습니다.

이 문서에 아래와 같이 첨부 파일이 있다고 가정합니다.

다음은 위에서 언급 한 문서 첨부 파일을 삭제하는 예입니다. 001 라는 데이터베이스에 존재하는 my_database CouchDB 서버에 저장됩니다.

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

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

db.removeAttachment('001', 'att_1.txt', '2-049f1c4ffa54576ec0947b65e34de423', 
   function(err, res) { 
   if (err) { 
      return console.log(err); 
   } else { 
      console.log(res+"Attachment Deleted successfully") 
   } 
});

위의 코드를 이름을 가진 파일에 저장하십시오. Remote_Delete_Attachment.js. 명령 프롬프트를 열고 다음을 사용하여 JavaScript 파일을 실행합니다.node 아래 그림과 같이.

C:\PouchDB_Examples >node Remote_Delete_Attachment.js

이렇게하면 기존 첨부 파일이 제거되고 다음 메시지가 표시됩니다.

Attachment Deleted successfully

문서를 다시 방문하면 다음 스크린 샷과 같이 첨부 파일이 삭제 된 것을 알 수 있습니다.

PouchDB의 가장 중요한 기능 중 하나는 복제입니다. 즉, 데이터베이스의 복사본을 만들 수 있습니다. 로컬에 저장된 PouchDB 인스턴스 또는 원격에 저장된 CouchDB 인스턴스를 복제 할 수 있습니다.

통사론

다음은 PouchDB에서 데이터베이스를 복제하는 구문입니다. 여기에source database타겟입니다. 이 방법으로 소스 및 대상 데이터베이스의 위치를 ​​문자열 형식으로 직접 전달하거나이를 나타내는 객체를 전달할 수 있습니다.

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

소스와 대상은 모두 PouchDB 인스턴스 또는 CouchDB 인스턴스 일 수 있습니다.

LocalDB를 CouchDB로 복제

이름을 가진 데이터베이스가 있다고 가정합니다. sample_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'}

다음은 이름이 지정된 데이터베이스의 복사본을 만드는 예입니다. sample_database CouchDB에 로컬로 저장됩니다.

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

var localdb = 'sample_database';

//Creating remote database object 
var remotedb = 'http://localhost:5984/sample_database';

//Replicating a local database to Remote 
PouchDB.replicate(localDB, remoteDB); 
console.log ("Database replicated successfully");

위의 코드를 이름이있는 파일에 저장하십시오. Replication_example.js. 명령 프롬프트를 열고 다음을 사용하여 JavaScript 파일을 실행합니다.node 아래 그림과 같이.

C:\PouchDB_Examples >node Replication_example.js

이렇게하면 CouchDB 인스턴스에 sample_database라는 데이터베이스의 복사본이 만들어지고 아래와 같이 콘솔에 메시지가 표시됩니다.

Database replicated successfully

다음 링크를 클릭하여 데이터베이스가 CouchDB 인스턴스에 복제되었는지 확인할 수 있습니다. http://127.0.0.1:5984/_utils/index.html.

클릭하면 CouchDB의 데이터베이스 목록을 볼 수 있습니다. 또한 데이터베이스 사본이sample_database 여기에 생성됩니다.

복제 된 데이터베이스를 선택하면 아래와 같이 내용을 볼 수 있습니다.

CouchDB를 PouchDB로 복제

이름을 가진 데이터베이스가 있다고 가정합니다. Remote_Database CouchDB에는 다음과 같은 내용이있는 doc1, doc2, doc3의 3 개의 문서가 포함되어 있습니다.

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

다음은 이름이 지정된 데이터베이스의 복사본을 만드는 예입니다. Remote_Database 로컬 스토리지의 CouchDB에 저장됩니다.

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

var localdb = 'sample_database';

var remotedb = 'http://localhost:5984/sample_database1';

//Replicating a local database to Remote
PouchDB.replicate(remotedb, localdb);
console.log("Database replicated successfully");

위의 코드를 이름을 가진 파일에 저장하십시오. Replication_example2.js. 명령 프롬프트를 열고 다음을 사용하여 JavaScript 파일을 실행합니다.node 아래 그림과 같이.

C:\PouchDB_Examples >node Replication_example2.js

이렇게하면 다음과 같은 데이터베이스의 복사본이 생성됩니다. remote_database PouchDB 인스턴스에서 아래와 같이 콘솔에 메시지를 표시합니다.

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에 로컬로 저장된 데이터베이스를 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에 저장된 데이터베이스의 객체입니다.

이름을 가진 데이터베이스가 있다고 가정합니다. local_database PouchDB에는 다음과 같은 내용이있는 doc1, doc2, doc3의 3 개의 문서가 포함되어 있습니다.

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

그리고 이름을 가진 데이터베이스가 있습니다. Remote_Database CouchDB에는 다음과 같은 내용이있는 2 개의 문서 doc1, doc2가 포함되어 있습니다.

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

다음은이 두 데이터베이스를 동기화하는 예입니다. 하나는 PouchDB에 저장되고 다른 하나는 CouchDB에 저장됩니다. replicate.to()replicate.from() 행동 양식.

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

//Creating local database object
var localDB = new PouchDB('local_database');

//Creating remote database object
var remoteDB = new PouchDB('http://localhost:5984/remote_database');

//Synchronising both databases
localDB.replicate.to(remoteDB);
remoteDB.replicate.from(localDB);
console.log("Databases synchronized successfully");

위의 코드를 이름을 가진 파일에 저장하십시오. Synchronising_databases.js. 명령 프롬프트를 열고 다음을 사용하여 JavaScript 파일을 실행합니다.node 아래 그림과 같이.

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)의 문서가 복사 된 것을 확인할 수 있습니다.

같은 방식으로 콘텐츠를 가져 오면 local_database PouchDB에 저장되면 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' 
      } 
   } 
]

위의 프로그램을 다시 작성할 수 있습니다. sync() 두 가지 방법 대신 PouchDB에서 제공하는 방법 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('http://localhost:5984/remote_database');

//Synchronising Remote and local databases
localDB.sync(remoteDB, function(err, response) {
   if (err) {
      return console.log(err);
   } else {
      console.log(response);
   }
});

위의 프로그램을 실행하면 다음과 같은 메시지를 표시하는 두 데이터베이스를 동기화합니다.

{ 
   push: { 
      ok: true,
      start_time: Fri Mar 25 2016 15:54:37 GMT+0530 (India Standard Time),
      docs_read: 6,
      docs_written: 6,
      doc_write_failures: 0,
      errors: [],
      last_seq: 10,
      status: 'complete',
      end_time: Fri Mar 25 2016 15:54:37 GMT+0530 (India Standard Time) 
   },
   pull: { 
      ok: true,
      start_time: Fri Mar 25 2016 15:54:37 GMT+0530 (India Standard Time),
      docs_read: 0,
      docs_written: 0,
      doc_write_failures: 0,
      errors: [],
      last_seq: 2,
      status: 'complete',
      end_time: Fri Mar 25 2016 15:54:37 GMT+0530 (India Standard Time) 
   } 
}

이 장에서는 PouchDB에서 대량 데이터의 압축 및 검색과 같은 개념에 대해 설명합니다.

압축

다음을 사용하여 사용하지 않는 데이터를 제거하여 데이터베이스 크기를 줄일 수 있습니다. compact()방법. 이 방법을 사용하여 로컬 데이터베이스와 원격 데이터베이스를 압축 할 수 있습니다.

다음은 사용 방법을 보여주는 예입니다. compact() PouchDB의 메소드.

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

//Creating the database object
var db = new PouchDB('sample_database');

db.compact(function (err, result) {
   if (err) {
      return console.log(err);
   } else {
      console.log(result);
   }
});

BulkGet 메서드

다음을 사용하여 문서 세트를 대량으로 검색 할 수 있습니다. bulkGet()방법. 이 메서드에는 id 및 _rev 집합을 전달해야합니다.

다음은 사용 방법을 보여주는 예입니다. bulkGet() PouchDB의 메소드.

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

//Creating the database object
var db = new PouchDB('my_database');

//Preparing documents
//Inserting Document
db.bulkGet({docs: [
   { id: "001", rev: "1-5dc593eda0e215c806677df1d12d5c47"},
   { id: "002", rev: "1-2bfad8a9e66d2679b99c0cab24bd9cc8"},
   { id: "003", rev: "1-7cff4a5da1f97b077a909ff67bd5b047"} ]}, function(err, result) {
   if (err) {
      return console.log(err);
   } else {
      console.log(result);
   }
});